1 /* 2 3 /usr/src/ext2ed/dir_com.c 4 5 A part of the extended file system 2 disk editor. 6 7 -------------------- 8 Handles directories. 9 -------------------- 10 11 This file contains the codes which allows the user to handle directories. 12 13 Most of the functions use the global variable file_info (along with the special directory fields there) to save 14 information and pass it between them. 15 16 Since a directory is just a big file which is composed of directory entries, you will find that 17 the functions here are a superset of those in the file_com.c source. 18 19 We assume that the user reached here using the dir command of the inode type and not by using settype dir, so 20 that init_dir_info is indeed called to gather the required information. 21 22 type_data is not changed! It still contains the inode of the file - We handle the directory in our own 23 variables, so that settype ext2_inode will "go back" to the inode of this directory. 24 25 First written on: April 28 1995 26 27 Copyright (C) 1995 Gadi Oxman 28 29 */ 30 31 #include "config.h" 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <string.h> 35 36 #include "ext2ed.h" 37 38 char name_search [80]; 39 long entry_num_search; 40 41 int init_dir_info (struct struct_file_info *info_ptr) 42 43 /* 44 45 This function is called by the inode of the directory when the user issues the dir command from the inode. 46 It is used to gather information about the inode and to reset some variables which we need in order to handle 47 directories. 48 49 */ 50 51 { 52 struct ext2_inode *ptr; 53 54 ptr=&type_data.u.t_ext2_inode; /* type_data contains the inode */ 55 56 info_ptr->inode_ptr=ptr; 57 info_ptr->inode_offset=device_offset; /* device offset contains the inode's offset */ 58 59 /* Reset the current position to the start */ 60 61 info_ptr->global_block_num=ptr->i_block [0]; 62 info_ptr->global_block_offset=ptr->i_block [0]*file_system_info.block_size; 63 info_ptr->block_num=0; 64 info_ptr->file_offset=0; 65 /* Set the size of the directory */ 66 67 info_ptr->blocks_count=(ptr->i_size+file_system_info.block_size-1)/file_system_info.block_size; 68 info_ptr->file_length=ptr->i_size; 69 70 info_ptr->level=0; /* We start using direct blocks */ 71 info_ptr->display=HEX; /* This is not actually used */ 72 73 info_ptr->dir_entry_num=0;info_ptr->dir_entries_count=0; /* We'll start at the first directory entry */ 74 info_ptr->dir_entry_offset=0; 75 76 /* Find dir_entries_count */ 77 78 info_ptr->dir_entries_count=count_dir_entries (); /* Set the total number of entries */ 79 80 return (1); 81 } 82 83 struct struct_file_info search_dir_entries (int (*action) (struct struct_file_info *info),int *status) 84 85 /* 86 This is the main function in this source file. Various actions are implemented using this basic function. 87 88 This routine runs on all directory entries in the current directory. 89 For each entry, action is called. We'll act according to the return code of action: 90 91 ABORT - Current dir entry is returned. 92 CONTINUE - Continue searching. 93 FOUND - Current dir entry is returned. 94 95 If the last entry is reached, it is returned, along with an ABORT status. 96 97 status is updated to the returned code of action. 98 */ 99 100 { 101 struct struct_file_info info; /* Temporary variables used to */ 102 struct ext2_dir_entry_2 *dir_entry_ptr; /* contain the current search entries */ 103 int return_code, next; 104 105 info=first_file_info; /* Start from the first entry - Read it */ 106 low_read (info.buffer,file_system_info.block_size,info.global_block_offset); 107 dir_entry_ptr=(struct ext2_dir_entry_2 *) (info.buffer+info.dir_entry_offset); 108 109 while (info.file_offset < info.file_length) { /* While we haven't reached the end */ 110 111 *status=return_code=action (&info); /* Call the client function to test */ 112 /* the current entry */ 113 if (return_code==ABORT || return_code==FOUND) 114 return (info); /* Stop, if so asked */ 115 116 /* Pass to the next entry */ 117 118 dir_entry_ptr=(struct ext2_dir_entry_2 *) (info.buffer+info.dir_entry_offset); 119 120 info.dir_entry_num++; 121 next = dir_entry_ptr->rec_len; 122 if (!next) 123 next = file_system_info.block_size - info.dir_entry_offset; 124 info.dir_entry_offset += next; 125 info.file_offset += next; 126 127 if (info.file_offset >= info.file_length) break; 128 129 if (info.dir_entry_offset >= file_system_info.block_size) { /* We crossed a block boundary */ 130 /* Find the next block, */ 131 info.block_num++; 132 info.global_block_num=file_block_to_global_block (info.block_num,&info); 133 info.global_block_offset=info.global_block_num*file_system_info.block_size; 134 info.file_offset=info.block_num*file_system_info.block_size; 135 info.dir_entry_offset=0; 136 /* read it and update the pointer */ 137 138 low_read (info.buffer,file_system_info.block_size,info.global_block_offset); 139 dir_entry_ptr=(struct ext2_dir_entry_2 *) (info.buffer+info.dir_entry_offset); 140 141 } 142 143 } 144 145 *status=ABORT;return (info); /* There was no match */ 146 } 147 148 long count_dir_entries (void) 149 150 /* 151 152 This function counts the number of entries in the directory. We just call search_dir_entries till the end. 153 The client function is action_count, which just tell search_dir_entries to continue. 154 155 */ 156 157 { 158 int status; 159 160 return (search_dir_entries (&action_count,&status).dir_entry_num); 161 } 162 163 int action_count (struct struct_file_info *info) 164 165 /* 166 167 Used by count_dir_entries above - This function is called by search_dir_entries, and it tells it to continue 168 searching, until we get to the last entry. 169 170 */ 171 172 { 173 return (CONTINUE); /* Just continue searching */ 174 } 175 176 void type_dir___cd (char *command_line) 177 178 /* 179 Changes to a directory, relative to the current directory. 180 181 This is a complicated operation, so I would repeat here the explanation from the design and 182 implementation document. 183 184 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 185 calling directly type_ext2___cd. 186 187 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 188 1 and into 2/3/4. 189 190 3. It is the first part of the path that we need to search for in the current directory. We search for it using 191 search_dir_entries, which accepts the action_name function as the client function. 192 193 4. search_dir_entries will scan the entire entries and will call our action_name function for each entry. 194 In action_name, the required name will be checked against the name of the current entry, and FOUND will be 195 returned when a match occurs. 196 197 5. If the required entry is found, we dispatch a remember command to insert the current inode (remember that 198 type_data is still intact and contains the inode of the current directory) into the object memory. 199 This is required to easily support symbolic links - If we find later that the inode pointed by the entry is 200 actually a symbolic link, we'll need to return to this point, and the above inode doesn't have (and can't have, 201 because of hard links) the information necessary to "move back". 202 203 6. We then dispatch a followinode command to reach the inode pointed by the required entry. This command will 204 automatically change the type to ext2_inode - We are now at an inode, and all the inode commands are available. 205 206 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", 207 and recursively call ourself (The type is dir again) by dispatching a cd command, with the rest of the path 208 as an argument. 209 210 8. If the inode's type is a symbolic link (only fast symbolic link were meanwhile implemented. I guess this is 211 typically the case.), we note the path it is pointing at, the saved inode is recalled, we dispatch dir to 212 get back to the original directory, and we call ourself again with the link path/rest of the path argument. 213 214 9. In any other case, we just stop at the resulting inode. 215 216 */ 217 218 { 219 int status; 220 char *ptr,full_dir_name [500],dir_name [500],temp [500],temp2 [500]; 221 struct struct_file_info info; 222 struct ext2_dir_entry_2 *dir_entry_ptr; 223 224 dir_entry_ptr=(struct ext2_dir_entry_2 *) (file_info.buffer+file_info.dir_entry_offset); 225 226 ptr=parse_word (command_line,dir_name); 227 228 if (*ptr==0) { /* cd alone will enter the highlighted directory */ 229 strncpy (full_dir_name,dir_entry_ptr->name,dir_entry_ptr->name_len); 230 full_dir_name [dir_entry_ptr->name_len]=0; 231 } 232 else 233 ptr=parse_word (ptr,full_dir_name); 234 235 ptr=strchr (full_dir_name,'/'); 236 237 if (ptr==full_dir_name) { /* Pathname is from root - Let the general cd do the job */ 238 sprintf (temp,"cd %s",full_dir_name);type_ext2___cd (temp);return; 239 } 240 241 if (ptr==NULL) { 242 strcpy (dir_name,full_dir_name); 243 full_dir_name [0]=0; 244 } 245 246 else { 247 strncpy (dir_name,full_dir_name,ptr-full_dir_name); 248 dir_name [ptr-full_dir_name]=0; 249 strcpy (full_dir_name,++ptr); 250 } 251 /* dir_name contains the current entry, while */ 252 /* full_dir_name contains the rest */ 253 254 strcpy (name_search,dir_name); /* name_search is used to hold the required entry name */ 255 256 if (dir_entry_ptr->name_len != strlen (dir_name) || 257 strncmp (dir_name,dir_entry_ptr->name,dir_entry_ptr->name_len)!=0) 258 info=search_dir_entries (&action_name,&status); /* Search for the entry. Answer in info. */ 259 else { 260 status=FOUND;info=file_info; 261 } 262 263 if (status==FOUND) { /* If found */ 264 file_info=info; /* Switch to it, by setting the global file_info */ 265 dispatch ("remember internal_variable"); /* Move the inode into the objects memory */ 266 267 dispatch ("followinode"); /* Go to the inode pointed by this directory entry */ 268 269 if (S_ISLNK (type_data.u.t_ext2_inode.i_mode)) {/* Symbolic link ? */ 270 271 if (type_data.u.t_ext2_inode.i_size > 60) { /* I'm lazy, I guess :-) */ 272 wprintw (command_win,"Error - Sorry, Only fast symbolic link following is currently supported\n"); 273 refresh_command_win (); 274 return; 275 } 276 /* Get the pointed name and append the previous path */ 277 278 strcpy (temp2,(unsigned char *) &type_data.u.t_ext2_inode.i_block); 279 strcat (temp2,"/"); 280 strcat (temp2,full_dir_name); 281 282 dispatch ("recall internal_variable"); /* Return to the original inode */ 283 dispatch ("dir"); /* and to the directory */ 284 285 sprintf (temp,"cd %s",temp2); /* And continue from there by dispatching a cd command */ 286 dispatch (temp); /* (which can call ourself or the general cd) */ 287 288 return; 289 } 290 291 if (S_ISDIR (type_data.u.t_ext2_inode.i_mode)) { /* Is it an inode of a directory ? */ 292 293 dispatch ("dir"); /* Yes - Pass to the pointed directory */ 294 295 if (full_dir_name [0] != 0) { /* And call ourself with the rest of the pathname */ 296 sprintf (temp,"cd %s",full_dir_name); 297 dispatch (temp); 298 } 299 300 return; 301 } 302 303 else { /* If we can't continue from here, we'll just stop */ 304 wprintw (command_win,"Can\'t continue - Stopping at last inode\n");refresh_command_win (); 305 return; 306 } 307 } 308 309 wprintw (command_win,"Error - Directory entry %s not found.\n",dir_name); /* Hmm, an invalid path somewhere */ 310 refresh_command_win (); 311 } 312 313 int action_name (struct struct_file_info *info) 314 315 /* 316 317 Compares the current search entry name (somewhere inside info) with the required name (in name_search). 318 Returns FOUND if found, or CONTINUE if not found. 319 320 */ 321 322 { 323 struct ext2_dir_entry_2 *dir_entry_ptr; 324 325 dir_entry_ptr=(struct ext2_dir_entry_2 *) (info->buffer+info->dir_entry_offset); 326 327 if (dir_entry_ptr->name_len != strlen (name_search)) 328 return (CONTINUE); 329 330 if (strncmp (dir_entry_ptr->name,name_search,dir_entry_ptr->name_len)==0) 331 return (FOUND); 332 333 return (CONTINUE); 334 } 335 336 void type_dir___entry (char *command_line) 337 338 /* 339 340 Selects a directory entry according to its number. 341 search_dir_entries is used along with action_entry_num, in the same fashion as the previous usage of search_dir_entries. 342 343 */ 344 345 { 346 int status; 347 struct struct_file_info info; 348 char *ptr,buffer [80]; 349 350 ptr=parse_word (command_line,buffer); 351 if (*ptr==0) { 352 wprintw (command_win,"Error - Argument_not_specified\n");wrefresh (command_win); 353 return; 354 } 355 ptr=parse_word (ptr,buffer); 356 entry_num_search=atol (buffer); 357 358 if (entry_num_search < 0 || entry_num_search >= file_info.dir_entries_count) { 359 wprintw (command_win,"Error - Entry number out of range\n");wrefresh (command_win); 360 return; 361 } 362 363 info=search_dir_entries (&action_entry_num,&status); 364 if (status==FOUND) { 365 file_info=info; 366 dispatch ("show"); 367 return; 368 } 369 #ifdef DEBUG 370 internal_error ("dir_com","type_dir___entry","According to our gathered data, we should have found this entry"); 371 #endif 372 } 373 374 int action_entry_num (struct struct_file_info *info) 375 376 /* 377 378 Used by the above function. Just compares the current number (in info) with the required one. 379 380 */ 381 382 { 383 if (info->dir_entry_num == entry_num_search) 384 return (FOUND); 385 386 return (CONTINUE); 387 } 388 389 void type_dir___followinode (char *command_line) 390 391 /* 392 393 Here we pass to the inode pointed by the current entry. 394 It involves computing the device offset of the inode and using directly the setoffset and settype commands. 395 396 */ 397 { 398 long inode_offset; 399 char buffer [80]; 400 401 struct ext2_dir_entry_2 *dir_entry_ptr; 402 403 low_read (file_info.buffer,file_system_info.block_size,file_info.global_block_offset); 404 dir_entry_ptr=(struct ext2_dir_entry_2 *) (file_info.buffer+file_info.dir_entry_offset); 405 406 inode_offset=inode_num_to_inode_offset (dir_entry_ptr->inode); /* Compute the inode's offset */ 407 sprintf (buffer,"setoffset %ld",inode_offset);dispatch (buffer); /* Move to it */ 408 sprintf (buffer,"settype ext2_inode");dispatch (buffer); /* and set the type to an inode */ 409 } 410 411 void type_dir___inode (char *command_line) 412 413 /* 414 415 Returns to the parent inode of the current directory. 416 This is trivial, as we type_data is still intact and contains the parent inode ! 417 418 */ 419 420 { 421 dispatch ("settype ext2_inode"); 422 } 423 424 425 void type_dir___show (char *command_line) 426 427 /* 428 429 We use search_dir_entries to run on all the entries. Each time, action_show will be called to show one entry. 430 431 */ 432 433 { 434 int status; 435 436 wmove (show_pad,0,0); 437 show_pad_info.max_line=-1; 438 439 search_dir_entries (&action_show,&status); 440 show_pad_info.line=file_info.dir_entry_num-show_pad_info.display_lines/2; 441 refresh_show_pad (); 442 show_dir_status (); 443 } 444 445 int action_show (struct struct_file_info *info) 446 447 /* 448 449 Show the current search entry (info) in one line. If the entry happens to be the current edited entry, it is highlighted. 450 451 */ 452 453 { 454 unsigned char temp [80]; 455 struct ext2_dir_entry_2 *dir_entry_ptr; 456 457 dir_entry_ptr=(struct ext2_dir_entry_2 *) (info->buffer+info->dir_entry_offset); 458 459 if (info->dir_entry_num == file_info.dir_entry_num) /* Highlight the current entry */ 460 wattrset (show_pad,A_REVERSE); 461 462 strncpy (temp,dir_entry_ptr->name,dir_entry_ptr->name_len); /* The name is not terminated */ 463 temp [dir_entry_ptr->name_len]=0; 464 if (dir_entry_ptr->name_len > (COLS - 55) && COLS > 55) 465 temp [COLS-55]=0; 466 wprintw (show_pad,"inode = %-8lu rec_len = %-4lu name_len = %-3lu name = %s\n", /* Display the various fields */ 467 dir_entry_ptr->inode,dir_entry_ptr->rec_len,dir_entry_ptr->name_len,temp); 468 469 show_pad_info.max_line++; 470 471 if (info->dir_entry_num == file_info.dir_entry_num) 472 wattrset (show_pad,A_NORMAL); 473 474 return (CONTINUE); /* And pass to the next */ 475 } 476 477 void type_dir___next (char *command_line) 478 479 /* 480 481 This function moves to the next directory entry. It just uses the current information and the entry command. 482 483 */ 484 485 { 486 int offset=1; 487 char *ptr,buffer [80]; 488 489 ptr=parse_word (command_line,buffer); 490 491 if (*ptr!=0) { 492 ptr=parse_word (ptr,buffer); 493 offset*=atol (buffer); 494 } 495 496 sprintf (buffer,"entry %ld",file_info.dir_entry_num+offset);dispatch (buffer); 497 498 } 499 500 void type_dir___prev (char *command_line) 501 502 { 503 int offset=1; 504 char *ptr,buffer [80]; 505 506 ptr=parse_word (command_line,buffer); 507 508 if (*ptr!=0) { 509 ptr=parse_word (ptr,buffer); 510 offset*=atol (buffer); 511 } 512 513 sprintf (buffer,"entry %ld",file_info.dir_entry_num-offset);dispatch (buffer); 514 } 515 516 void show_dir_status (void) 517 518 /* 519 520 Various statistics about the directory. 521 522 */ 523 524 { 525 long inode_num; 526 527 wmove (show_win,0,0); 528 wprintw (show_win,"Directory listing. Block %ld. ",file_info.global_block_num); 529 wprintw (show_win,"Directory entry %ld of %ld.\n",file_info.dir_entry_num,file_info.dir_entries_count-1); 530 wprintw (show_win,"Directory Offset %ld of %ld. ",file_info.file_offset,file_info.file_length-1); 531 532 inode_num=inode_offset_to_inode_num (file_info.inode_offset); 533 wprintw (show_win,"File inode %ld. Indirection level %ld.\n",inode_num,file_info.level); 534 535 refresh_show_win (); 536 } 537 538 void type_dir___remember (char *command_line) 539 540 /* 541 542 This is overrided here because we don't remember a directory - It is too complicated. Instead, we remember the 543 inode of the current directory. 544 545 */ 546 547 { 548 int found=0; 549 long entry_num; 550 char *ptr,buffer [80]; 551 struct struct_descriptor *descriptor_ptr; 552 553 ptr=parse_word (command_line,buffer); 554 555 if (*ptr==0) { 556 wprintw (command_win,"Error - Argument not specified\n");wrefresh (command_win); 557 return; 558 } 559 560 ptr=parse_word (ptr,buffer); 561 562 entry_num=remember_lifo.entries_count++; 563 if (entry_num>REMEMBER_COUNT-1) { 564 entry_num=0; 565 remember_lifo.entries_count--; 566 } 567 568 descriptor_ptr=first_type; 569 while (descriptor_ptr!=NULL && !found) { 570 if (strcmp (descriptor_ptr->name,"ext2_inode")==0) 571 found=1; 572 else 573 descriptor_ptr=descriptor_ptr->next; 574 } 575 576 577 remember_lifo.offset [entry_num]=device_offset; 578 remember_lifo.type [entry_num]=descriptor_ptr; 579 strcpy (remember_lifo.name [entry_num],buffer); 580 581 wprintw (command_win,"Object %s in Offset %ld remembered as %s\n",descriptor_ptr->name,device_offset,buffer); 582 wrefresh (command_win); 583 } 584 585 void type_dir___set (char *command_line) 586 587 /* 588 589 Since the dir object doesn't have variables, we provide the impression that it has here. ext2_dir_entry was not used 590 because it is of variable length. 591 592 */ 593 594 { 595 int found=0; 596 unsigned char *ptr,buffer [80],variable [80],value [80],temp [80]; 597 struct ext2_dir_entry_2 *dir_entry_ptr; 598 599 dir_entry_ptr=(struct ext2_dir_entry_2 *) (file_info.buffer+file_info.dir_entry_offset); 600 601 ptr=parse_word (command_line,buffer); 602 if (*ptr==0) { 603 wprintw (command_win,"Error - Missing arguments\n");refresh_command_win (); 604 return; 605 } 606 parse_word (ptr,buffer); 607 ptr=strchr (buffer,'='); 608 if (ptr==NULL) { 609 wprintw (command_win,"Error - Bad syntax\n");refresh_command_win ();return; 610 } 611 strncpy (variable,buffer,ptr-buffer);variable [ptr-buffer]=0; 612 strcpy (value,++ptr); 613 614 if (strcasecmp ("inode",variable)==0) { 615 found=1; 616 dir_entry_ptr->inode=atol (value); 617 wprintw (command_win,"Variable %s set to %lu\n",variable,dir_entry_ptr->inode);refresh_command_win (); 618 619 } 620 621 if (strcasecmp ("rec_len",variable)==0) { 622 found=1; 623 dir_entry_ptr->rec_len=(unsigned int) atol (value); 624 wprintw (command_win,"Variable %s set to %lu\n",variable,dir_entry_ptr->rec_len);refresh_command_win (); 625 626 } 627 628 if (strcasecmp ("name_len",variable)==0) { 629 found=1; 630 dir_entry_ptr->name_len=(unsigned int) atol (value); 631 wprintw (command_win,"Variable %s set to %lu\n",variable,dir_entry_ptr->name_len);refresh_command_win (); 632 633 } 634 635 if (strcasecmp ("name",variable)==0) { 636 found=1; 637 if (strlen (value) > dir_entry_ptr->name_len) { 638 wprintw (command_win,"Error - Length of name greater then name_len\n"); 639 refresh_command_win ();return; 640 } 641 strncpy (dir_entry_ptr->name,value,strlen (value)); 642 wprintw (command_win,"Variable %s set to %s\n",variable,value);refresh_command_win (); 643 644 } 645 646 if (found) { 647 wattrset (show_pad,A_REVERSE); 648 strncpy (temp,dir_entry_ptr->name,dir_entry_ptr->name_len); 649 temp [dir_entry_ptr->name_len]=0; 650 wmove (show_pad,file_info.dir_entry_num,0); 651 wprintw (show_pad,"inode = %-8lu rec_len = %-4lu name_len = %-3lu name = %s\n", 652 dir_entry_ptr->inode,dir_entry_ptr->rec_len,dir_entry_ptr->name_len,temp); 653 wattrset (show_pad,A_NORMAL); 654 show_pad_info.line=file_info.dir_entry_num-show_pad_info.display_lines/2; 655 refresh_show_pad (); 656 show_dir_status (); 657 } 658 659 else { 660 wprintw (command_win,"Error - Variable %s not found\n",variable); 661 refresh_command_win (); 662 } 663 664 } 665 666 void type_dir___writedata (char *command_line) 667 668 /* 669 670 We need to override this since the data is not in type_data. Instead, we have to write the buffer which corresponds 671 to the current block. 672 673 */ 674 675 { 676 low_write (file_info.buffer,file_system_info.block_size,file_info.global_block_offset); 677 return; 678 } 679
