1 /* 2 3 /usr/src/ext2ed/main.c 4 5 A part of the extended file system 2 disk editor. 6 7 ------------ 8 Main program 9 ------------ 10 11 This file mostly contains: 12 13 1. A list of global variables used through the entire program. 14 2. The parser, which asks the command line from the user. 15 3. The dispatcher, which analyzes the command line and calls the appropriate handler function. 16 4. A command pattern matcher which is used along with the readline completion feature. 17 5. A function which tells the user that an internal error has occured. 18 19 First written on: March 30 1995 20 21 Copyright (C) 1995 Gadi Oxman 22 23 */ 24 25 #include <stdio.h> 26 #include <stdlib.h> 27 #include <string.h> 28 #include <signal.h> 29 30 #ifdef HAVE_READLINE 31 #include <readline.h> 32 #include <history.h> 33 #endif 34 35 #ifdef HAVE_GETOPT_H 36 #include <getopt.h> 37 #else 38 extern int optind; 39 extern char *optarg; 40 #endif 41 42 #include "ext2ed.h" 43 44 /* Global variables */ 45 46 /* 47 48 Configuration file options 49 50 The following variables will be set by init.c to the values selected in the user configuration file. 51 They are initialized below to some logical defaults. 52 53 */ 54 55 56 char Ext2Descriptors [200]="ext2.descriptors"; /* The location of the ext2 filesystem object definition */ 57 char AlternateDescriptors [200]=""; /* We allow the user to define additional structures */ 58 char LogFile [200]="ext2ed.log"; /* The location of the log file - Each write will be logged there */ 59 int LogChanges=1; /* 1 enables logging, 0 diables logging */ 60 int AllowChanges=0; /* When set, the enablewrite command will fail */ 61 int AllowMountedRead=0; /* Behavior when trying to open a mounted filesystem read-only */ 62 int ForceExt2=0; /* When set, ext2 autodetection is overridden */ 63 int DefaultBlockSize=1024; 64 unsigned long DefaultTotalBlocks=2097151; 65 unsigned long DefaultBlocksInGroup=8192; /* The default values are used when an ext2 filesystem is not */ 66 int ForceDefault=0; /* detected, or ForceDefault is set */ 67 68 char last_command_line [80]; /* A simple one command cache, in addition to the readline history */ 69 70 char device_name [80]; /* The location of the filesystem */ 71 FILE *device_handle=NULL; /* This is passed to the fopen / fread ... commands */ 72 long device_offset; /* The current position in the filesystem */ 73 /* Note that we have a 2 GB limitation */ 74 75 int mounted=0; /* This is set when we find that the filesystem is mounted */ 76 77 struct struct_commands general_commands,ext2_commands; /* Used to define the general and ext2 commands */ 78 struct struct_descriptor *first_type,*last_type,*current_type; /* Used to access the double linked list */ 79 struct struct_type_data type_data; /* The current data is sometimes stored here */ 80 struct struct_file_system_info file_system_info; /* Essential information on the filesystem */ 81 struct struct_file_info file_info,first_file_info; /* Used by file_com.c to access files */ 82 struct struct_group_info group_info; /* Used by group_com.c */ 83 struct struct_super_info super_info; /* Used by super_com.c */ 84 struct struct_remember_lifo remember_lifo; /* A circular memory of objects */ 85 struct struct_block_bitmap_info block_bitmap_info; /* Used by blockbitmap_com.c */ 86 struct struct_inode_bitmap_info inode_bitmap_info; /* Used by inodebitmap_com.c */ 87 88 int redraw_request=0; /* Is set by a signal handler to handle terminal */ 89 /* screen size change. */ 90 91 92 /* 93 * We just call the parser to get commands from the user. We quit when 94 * parser returns. 95 */ 96 int main (int argc, char **argv) 97 { 98 int write_priv = 0; 99 int c; 100 char *buf; 101 102 if (!init ()) 103 return (1); 104 while ((c = getopt (argc, argv, "w")) != EOF) { 105 switch (c) { 106 case 'w': 107 write_priv++; 108 break; 109 } 110 } 111 if (optind < argc) { 112 buf = malloc(strlen(argv[optind]) + 32); 113 if (!buf) { 114 fprintf(stderr, "Couldn't allocate filename buffer\n"); 115 exit(1); 116 } 117 strcpy(buf, "set_device "); 118 strcat(buf, argv[optind]); 119 set_device(buf); 120 free(buf); 121 if (write_priv) { 122 wprintw (command_win,"\n"); 123 enable_write("enable_write"); 124 } 125 } 126 parser (); /* Get and parse user commands */ 127 prepare_to_close(); /* Do some cleanup */ 128 printf("Quitting ...\n"); 129 return(0); 130 } 131 132 133 /* 134 * Read a character from the command window 135 */ 136 int command_read_key() 137 { 138 int key = 0; 139 140 while (!key) { 141 if (redraw_request) { 142 redraw_all(); 143 redraw_request=0; 144 } 145 key = wgetch(command_win); 146 switch (key) { 147 case 0x1A: 148 key = 0; 149 kill(getpid(), SIGTSTP); 150 break; 151 152 case KEY_NPAGE: 153 pgdn(""); 154 refresh_command_win (); 155 break; 156 157 case KEY_PPAGE: 158 pgup(""); 159 refresh_command_win (); 160 break; 161 case ERR: 162 key = 0; 163 break; 164 165 case KEY_BACKSPACE: 166 key = '\b'; 167 } 168 if ((key < 32 && key != '\b' && key != '\n') || 169 (key > 127)) 170 key = 0; 171 } 172 return key; 173 } 174 175 #ifdef HAVE_READLINE 176 int rl_getc_replacement(FILE *f) 177 { 178 int key = command_read_key(); 179 180 if (key == '\b') { 181 if (rl_point > 0) 182 wprintw(command_win, "\b \b"); 183 } else 184 wprintw(command_win, "%c", key); 185 return key; 186 } 187 188 /* 189 * This function asks the user for a command and calls the dispatcher 190 * function, dispatch, to analyze it. We use the readline library 191 * function readline to read the command, hence all the usual readline 192 * keys are available. The new command is saved both in the 193 * readline's history and in our tiny one-command cache, so that only 194 * the enter key is needed to retype it. 195 */ 196 void parser (void) 197 { 198 char *ptr,command_line [80]; 199 int quit=0; 200 201 #if 0 202 noecho(); 203 cbreak(); 204 keypad(command_win, 1); 205 wtimeout(command_win, 100); 206 207 rl_getc_function = rl_getc_replacement; 208 #endif 209 210 while (!quit) { 211 /* Terminal screen size has changed */ 212 if (redraw_request) { 213 redraw_all(); 214 redraw_request=0; 215 } 216 217 wmove (command_win,0,0); 218 wclrtoeol (command_win); 219 wprintw (command_win,"ext2ed > "); 220 refresh_command_win (); 221 222 /* 223 * The ncurses library optimizes cursor movement by 224 * keeping track of the cursor position. However, by 225 * using the readline library I'm breaking its 226 * assumptions. The double -1 arguments tell ncurses 227 * to disable cursor movement optimization this 228 * time. 229 */ 230 mvcur (-1,-1,LINES-COMMAND_WIN_LINES,0); 231 232 /* echo (); */ 233 ptr=readline ("ext2ed > "); 234 /* noecho (); */ 235 236 /* 237 * Readline allocated the buffer - Copy the string 238 * and free the allocated buffer 239 * XXX WHY??? 240 */ 241 strcpy (command_line,ptr); 242 free (ptr); 243 244 if (*command_line != 0) 245 add_history (command_line); 246 247 /* If only enter was pressed, recall the last command */ 248 if (*command_line==0) 249 strcpy (command_line,last_command_line); 250 251 /* Emulate readline's actions for ncurses */ 252 mvcur (-1,-1,LINES-COMMAND_WIN_LINES,0); 253 werase (command_win); 254 wprintw (command_win,"ext2ed > "); 255 wprintw (command_win,command_line); 256 wprintw (command_win,"\n"); 257 refresh_command_win (); 258 259 /* Save this command in our tiny cache */ 260 strcpy (last_command_line,command_line); 261 262 /* And call dispatch to do the actual job */ 263 quit=dispatch (command_line); 264 } 265 } 266 #else 267 void read_line(char * foo) { 268 char * chptr = foo; 269 int ch; 270 int done = 0; 271 272 while (!done && (ch = command_read_key())) { 273 switch (ch) { 274 case '\n': 275 done = 1; 276 break; 277 278 case '\b': 279 if (chptr > foo) { 280 wprintw(command_win, "\b \b"); 281 chptr--; 282 } 283 break; 284 285 default: 286 if (ch > 256) 287 break; 288 if (ch == '\n') break; 289 *chptr++ = ch; 290 wprintw(command_win, "%c", ch); 291 break; 292 } 293 } 294 *chptr = '\0'; 295 } 296 297 void parser (void) 298 { 299 char command_line [80]; 300 int quit=0; 301 302 noecho(); 303 cbreak(); 304 wtimeout(command_win, 100); 305 keypad(command_win, 1); 306 307 while (!quit) { 308 /* Terminal screen size has changed */ 309 if (redraw_request) { 310 redraw_all(); 311 redraw_request=0; 312 } 313 314 wmove (command_win,0,0);wclrtoeol (command_win); 315 316 wmove(command_win, 0, 0); 317 wprintw(command_win, "ext2ed > "); 318 read_line(command_line); 319 320 /* If only enter was pressed, recall the last command */ 321 if (*command_line==0) 322 strcpy (command_line,last_command_line); 323 324 mvcur (-1,-1,LINES-COMMAND_WIN_LINES + 1,0); 325 326 strcpy (last_command_line,command_line); /* Save this command in our tiny cache */ 327 328 /* And call dispatch to do the actual job */ 329 quit=dispatch (command_line); 330 } 331 } 332 #endif 333 334 335 /* 336 * This is a very important function. Its task is to recieve a command 337 * name and link it to a C function. There are three types of commands: 338 * 339 * 1. General commands - Always available and accessed through 340 * general_commands. 341 * 2. Ext2 specific commands - Available when editing an ext2 342 * filesystem, accessed through ext2_commands. 343 * 3. Type specific commands - Those are changing according to the 344 * current type. The global variable current_type points to the 345 * current object definition (of type struct_descriptor). In it, the 346 * struct_commands entry contains the type specific commands links. 347 * 348 * Overriding is an important feature - Much like in C++ : The same 349 * command name can dispatch to different functions. The overriding 350 * priority is 3,2,1; That is - A type specific command will always 351 * override a general command. This is used through the program to 352 * allow fine tuned operation. 353 * 354 * When an handling function is found, it is called along with the 355 * command line that was passed to us. The handling function is then 356 * free to interpert the arguments in its own style. 357 */ 358 int dispatch (char *command_line) 359 { 360 int i,found=0; 361 362 char command [80]; 363 364 parse_word (command_line,command); 365 366 if (strcasecmp (command,"quit")==0) return (1); 367 368 /* 1. Search for type specific commands FIRST - Allows 369 overriding of a general command */ 370 371 if (current_type != NULL) 372 for (i=0; 373 i<=current_type->type_commands.last_command && !found; 374 i++) { 375 if (strcasecmp (command,current_type->type_commands.names [i])==0) { 376 (*current_type->type_commands.callback [i]) (command_line); 377 found=1; 378 } 379 } 380 381 /* 2. Now search for ext2 filesystem general commands */ 382 383 if (!found) 384 for (i=0;i<=ext2_commands.last_command && !found;i++) { 385 if (strcasecmp (command,ext2_commands.names [i])==0) { 386 (*ext2_commands.callback [i]) (command_line); 387 found=1; 388 } 389 } 390 391 392 /* 3. If not found, search the general commands */ 393 394 if (!found) 395 for (i=0;i<=general_commands.last_command && !found;i++) { 396 if (strcasecmp (command,general_commands.names [i])==0) { 397 (*general_commands.callback [i]) (command_line); 398 found=1; 399 } 400 } 401 402 /* 4. If not found, issue an error message and return */ 403 404 if (!found) { 405 wprintw (command_win,"Error: Unknown command\n"); 406 refresh_command_win (); 407 } 408 409 return (0); 410 } 411 412 413 /* 414 * 415 * This function copies the next word in source to the variable dest, 416 * ignoring whitespaces. It returns a pointer to the next word in 417 * source. It is used to split the command line into command and arguments. 418 */ 419 char *parse_word (char *source,char *dest) 420 { 421 char ch,*source_ptr,*target_ptr; 422 423 if (*source==0) { 424 *dest=0; 425 return (source); 426 }; 427 428 source_ptr=source;target_ptr=dest; 429 do { 430 ch=*source_ptr++; 431 } while (! (ch>' ' && ch<='z') && ch!=0); 432 433 while (ch>' ' && ch<='z') { 434 *target_ptr++=ch; 435 ch=*source_ptr++; 436 } 437 438 *target_ptr=0; 439 440 source_ptr--; 441 do { 442 ch=*source_ptr++; 443 } while (! (ch>' ' && ch<='z') && ch!=0); 444 445 return (--source_ptr); 446 } 447 448 /* 449 * text is the partial command entered by the user; We assume that it 450 * is a part of a command - I didn't write code for smarter completion. 451 * 452 * The state variable is an index which tells us how many possible 453 * completions we already returned to readline. 454 * 455 * We return only one possible completion or (char *) NULL if there 456 * are no more completions. This function will be called by readline 457 * over and over until we tell it to stop. 458 * 459 * While scanning for possible completions, we use the same priority 460 * definition which was used in dispatch. 461 */ 462 #if HAVE_READLINE 463 char *complete_command (char *text,int state) 464 { 465 int state_index=-1; 466 int i,len; 467 468 len=strlen (text); 469 470 /* Is the command type specific ? */ 471 472 if (current_type != NULL) 473 for (i=0;i<=current_type->type_commands.last_command;i++) { 474 if (strncmp (current_type->type_commands.names [i],text,len)==0) { 475 state_index++; 476 if (state==state_index) { 477 return (dupstr (current_type->type_commands.names [i])); 478 } 479 } 480 } 481 482 /* No, pehaps ext2 specific command then ? */ 483 484 for (i=0;i<=ext2_commands.last_command;i++) { 485 if (strncmp (ext2_commands.names [i],text,len)==0) { 486 state_index++; 487 if (state==state_index) 488 return (dupstr (ext2_commands.names [i])); 489 } 490 } 491 492 493 /* Check for a general command */ 494 495 for (i=0;i<=general_commands.last_command;i++) { 496 if (strncmp (general_commands.names [i],text,len)==0) { 497 state_index++; 498 if (state==state_index) 499 return (dupstr (general_commands.names [i])); 500 } 501 } 502 503 /* quit is handled differently */ 504 505 if (strncmp ("quit",text,len)==0) { 506 state_index++; 507 if (state==state_index) 508 return (dupstr ("quit")); 509 } 510 511 /* No more completions */ 512 513 return ((char *) NULL); 514 } 515 #endif 516 517 518 /* 519 * Nothing special - Just allocates enough space and copy the string. 520 */ 521 char *dupstr (char *src) 522 { 523 char *ptr; 524 525 ptr=(char *) malloc (strlen (src)+1); 526 strcpy (ptr,src); 527 return (ptr); 528 } 529 530 #ifdef DEBUG 531 /* 532 * This function reports an internal error. It is almost not used. One 533 * place in which I do check for internal errors is disk.c. 534 * 535 * We just report the error, and try to continue ... 536 */ 537 void internal_error (char *description,char *source_name,char *function_name) 538 { 539 wprintw (command_win,"Internal error - Found by source: %s.c , function: %s\n",source_name,function_name); 540 wprintw (command_win,"\t%s\n",description); 541 wprintw (command_win,"Press enter to (hopefully) continue\n"); 542 refresh_command_win ();getch ();werase (command_win); 543 } 544 545 #endif 546
