home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume11 / mtools / part02 / putfat.c < prev    next >
C/C++ Source or Header  |  1987-08-27  |  3KB  |  137 lines
  1. /*
  2.  * putfat(), writedir(), zapit(), writefat()
  3.  */
  4.  
  5. #include <stdio.h>
  6. #include "msdos.h"
  7. #undef DUP_FAT
  8.  
  9. extern int fd, fat_len, dir_chain[25];
  10. extern unsigned char *fatbuf;
  11.  
  12. /*
  13.  * Puts a code into the FAT table.  Is the opposite of getfat().  No
  14.  * sanity checking is done on the code.  Returns a 1 on error.
  15.  */
  16.  
  17. int
  18. putfat(num, code)
  19. int num;
  20. unsigned int code;
  21. {
  22. /*
  23.  *    |    byte n     |   byte n+1    |   byte n+2    |
  24.  *    |0|1|2|3|4|5|6|7|0|1|2|3|4|5|6|7|0|1|2|3|4|5|6|7|
  25.  *    | | | | | | | | | | | | | | | | | | | | | | | | |
  26.  *    |  n.0  |  n.5  | n+1.0 | n+1.5 | n+2.0 | n+2.5 |
  27.  *        \_____  \____   \______/________/_____   /
  28.  *          ____\______\________/   _____/  ____\_/
  29.  *         /     \      \          /       /     \
  30.  *    | n+1.5 |  n.0  |  n.5  | n+2.0 | n+2.5 | n+1.0 |
  31.  *    |      FAT entry k      |    FAT entry k+1      |
  32.  */
  33.     int start;
  34.                     /* which bytes contain the entry */
  35.     start = num * 3 / 2;
  36.     if (start < 0 || start+1 > (fat_len * MSECSIZ))
  37.         return(1);
  38.                     /* (odd) not on byte boundary */
  39.     if (num % 2) {
  40.         *(fatbuf+start) = (*(fatbuf+start) & 0x0f) + ((code << 4) & 0xf0);
  41.         *(fatbuf+start+1) = (code >> 4) & 0xff;
  42.     }
  43.                     /* (even) on byte boundary */
  44.     else {
  45.         *(fatbuf+start) = code & 0xff;
  46.         *(fatbuf+start+1) = (*(fatbuf+start+1) & 0xf0) + ((code >> 8) & 0x0f);
  47.     }
  48.     return(0);
  49. }
  50.  
  51. /*
  52.  * Write a directory entry.  The first argument is the directory entry
  53.  * number to write to.  The second is a pointer to the directory itself.
  54.  * All errors are fatal.
  55.  */
  56.  
  57. writedir(num, dir)
  58. int num;
  59. struct directory *dir;
  60. {
  61.     int skip, entry;
  62.     void exit(), perror();
  63.     static struct directory dirs[16];
  64.                     /* which sector */
  65.     skip = dir_chain[num / 16];
  66.  
  67.     move(skip);
  68.                     /* read the sector */
  69.     if (read(fd, (char *) &dirs[0], MSECSIZ) != MSECSIZ) {
  70.         perror("writedir: read");
  71.         exit(1);
  72.     }
  73.                     /* which entry in sector */
  74.     entry = num % 16;
  75.                     /* copy the structure */
  76.     dirs[entry] = *dir;
  77.     move(skip);
  78.                     /* write the sector */
  79.     if (write(fd, (char *) &dirs[0], MSECSIZ) != MSECSIZ) {
  80.         perror("writedir: write");
  81.         exit(1);
  82.     }
  83.     return;
  84. }
  85.  
  86. /*
  87.  * Remove a string of FAT entries (delete the file).  The argument is
  88.  * the beginning of the string.  Does not consider the file length, so
  89.  * if FAT is corrupted, watch out!  All errors are fatal.
  90.  */
  91.  
  92. zapit(fat)
  93. int fat;
  94. {
  95.     int next;
  96.  
  97.     while (1) {
  98.                     /* get next cluster number */
  99.         next = getfat(fat);
  100.                     /* mark current cluster as empty */
  101.         if (putfat(fat, 0) || next == -1) {
  102.             fprintf(stderr, "zapit: FAT problem\n");
  103.             exit(1);
  104.         }
  105.         if (next >= 0xff8)
  106.             break;
  107.         fat = next;
  108.     }
  109.     return;
  110. }
  111.  
  112. /*
  113.  * Write the FAT table to the disk.  Up to now the FAT manipulation has
  114.  * been done in memory.  All errors are fatal.  (Might not be too smart
  115.  * to wait till the end of the program to write the table.  Oh well...)
  116.  */
  117.  
  118. writefat()
  119. {
  120.     int buflen;
  121.  
  122.     move(1);
  123.     buflen = fat_len * MSECSIZ;
  124.     if (write(fd, fatbuf, buflen) != buflen) {
  125.         perror("writefat: write");
  126.         exit(1);
  127.     }
  128. #ifdef DUP_FAT
  129.                     /* the duplicate FAT table */
  130.     if (write(fd, fatbuf, buflen) != buflen) {
  131.         perror("writefat: write");
  132.         exit(1);
  133.     }
  134. #endif DUP_FAT
  135.     return;
  136. }
  137.