• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号
登陆 注册

【操作系统】C语言编写的FAT16文件系统

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

 

这是操作系统的期末课程设计作业之一，主要功能是在物理内存中虚拟出一个1M大小的FAT16的文件系统，然后把它读入内存中,进行具体的文件操作,具体的实用性不大，主要目的是为了练习C语言,帮助理解文件系统的特点,代码如下：

 

  1. #include <stdio.h>  
  2. #include <malloc.h>  
  3. #include <string.h>  
  4. #include <time.h>  
  5.   
  6. #define BLOCKSIZE 1024  // 磁盘块大小  
  7. #define SIZE 1024000  // 虚拟磁盘空间大小  
  8. #define END 65535  // FAT中的文件结束标志  
  9. #define FREE 0  // FAT中盘块空闲标志  
  10. #define ROOTBLOCKNUM 2  // 根目录区所占盘块数  
  11. #define MAXOPENFILE 10  // 最多同时打开文件个数t  
  12. #define MAXTEXT 10000  
  13.   
  14. /* 文件控制块 */  
  15. typedef struct FCB  
  16. {  
  17.     char filename[8];  // 文件名  
  18.     char exname[3];  // 文件扩展名  
  19.     unsigned char attribute;  // 文件属性字段，值为0时表示目录文件，值为1时表示数据文件  
  20.     unsigned short time;  // 文件创建时间  
  21.     unsigned short date;  // 文件创建日期  
  22.     unsigned short first;  // 文件起始盘块号  
  23.     unsigned long length;  // 文件长度  
  24.     char free;  // 表示目录项是否为空，若值为0，表示空，值为1，表示已分配  
  25. }fcb;  
  26.   
  27. /* 文件分配表 */  
  28. typedef struct FAT  
  29. {  
  30.     unsigned short id;  // 磁盘块的状态（空闲的，最后的，下一个）  
  31. }fat;  
  32. /* 用户打开文件表 */  
  33. typedef struct USEROPEN  
  34. {  
  35.     char filename[8];  // 文件名  
  36.     char exname[3];  // 文件扩展名  
  37.     unsigned char attribute;  // 文件属性字段，值为0时表示目录文件，值为1时表示数据文件  
  38.     unsigned short time;  // 文件创建时间  
  39.     unsigned short date;  // 文件创建日期  
  40.     unsigned short first;  // 文件起始盘块号  
  41.     unsigned long length;  // 文件长度（对数据文件是字节数，对目录文件可以是目录项个数）  
  42.     char free;  // 表示目录项是否为空，若值为0，表示空，值为1，表示已分配  
  43.   
  44.     unsigned short dirno;  // 相应打开文件的目录项在父目录文件中的盘块号  
  45.     int diroff;  // 相应打开文件的目录项在父目录文件的dirno盘块中的目录项序号  
  46.     char dir[80];  // 相应打开文件所在的目录名，这样方便快速检查出指定文件是否已经打开  
  47.     int father;  // 父目录在打开文件表项的位置  
  48.     int count;  // 读写指针在文件中的位置,文件的总字符数  
  49.     char fcbstate;  // 是否修改了文件的FCB的内容，如果修改了置为1，否则为0  
  50.     char topenfile;  // 表示该用户打开表项是否为空，若值为0，表示为空，否则表示已被某打开文件占据  
  51. }useropen;  
  52.   
  53. /* 引导块 */  
  54. typedef struct BLOCK0  
  55. {  
  56.     char magic[10];  // 文件系统魔数  
  57.     char information[200];  // 存储一些描述信息，如磁盘块大小、磁盘块数量、最多打开文件数等  
  58.     unsigned short root;  // 根目录文件的起始盘块号  
  59.     unsigned char *startblock;  // 虚拟磁盘上数据区开始位置  
  60. }block0;  
  61. unsigned char *myvhard;  // 指向虚拟磁盘的起始地址  
  62. useropen openfilelist[MAXOPENFILE];  // 用户打开文件表数组  
  63. int curdir;  // 用户打开文件表中的当前目录所在打开文件表项的位置  
  64. char currentdir[80];  // 记录当前目录的目录名（包括目录的路径）  
  65. unsigned char* startp;  // 记录虚拟磁盘上数据区开始位置  
  66. char myfilename[] = "myfilesys";//文件系统的文件名  
  67.   
  68. void startsys();  // 进入文件系统  
  69. void my_format();  // 磁盘格式化  
  70. void my_cd(char *dirname);  // 更改当前目录  
  71. void my_mkdir(char *dirname);  // 创建子目录  
  72. void my_rmdir(char *dirname);  // 删除子目录  
  73. void my_ls();  // 显示目录  
  74. void my_create (char *filename);  // 创建文件  
  75. void my_rm(char *filename);  // 删除文件  
  76. int my_open(char *filename);  // 打开文件  
  77. int my_close(int fd);  // 关闭文件  
  78. int my_write(int fd);  // 写文件  
  79. int do_write(int fd, char *text, int len, char wstyle);  // 实际写文件  
  80. int my_read (int fd, int len);  // 读文件  
  81. int do_read (int fd, int len,char *text);  // 实际读文件  
  82. void my_exitsys();  // 退出文件系统  
  83. unsigned short findblock();  // 寻找空闲盘块  
  84. int findopenfile();  // 寻找空闲文件表项  
  85. void startsys()  
  86. {  
  87.     FILE *fp;  
  88.     unsigned char buf[SIZE];  
  89.     fcb *root;  
  90.     int i;  
  91.     myvhard = (unsigned char *)malloc(SIZE);//申请虚拟磁盘空间  
  92.     memset(myvhard, 0, SIZE);//将myvhard中前SIZE个字节用 0 替换并返回 myvhard  
  93.     if((fp = fopen(myfilename, "r")) != NULL)  
  94.     {  
  95.         fread(buf, SIZE, 1, fp);//将二进制文件读取到缓冲区  
  96.         fclose(fp);//关闭打开的文件，缓冲区数据写入文件，释放系统提供文件资源  
  97.         if(strcmp(((block0 *)buf)->magic, "10101010"))//判断开始的8个字节内容是否为文件系统魔数  
  98.         {  
  99.             printf("myfilesys is not exist,begin to creat the file...\n");  
  100.             my_format();  
  101.         }  
  102.         else  
  103.         {  
  104.             for(i = 0; i < SIZE; i++)  
  105.                 myvhard[i] = buf[i];  
  106.         }  
  107.     }  
  108.     else  
  109.     {  
  110.         printf("myfilesys is not exist,begin to creat the file...\n");  
  111.         my_format();  
  112.     }  
  113.     root = (fcb *)(myvhard + 5 * BLOCKSIZE);  
  114.     strcpy(openfilelist[0].filename, root->filename);  
  115.     strcpy(openfilelist[0].exname, root->exname);  
  116.     openfilelist[0].attribute = root->attribute;  
  117.     openfilelist[0].time = root->time;  
  118.     openfilelist[0].date = root->date;  
  119.     openfilelist[0].first = root->first;  
  120.     openfilelist[0].length = root->length;  
  121.     openfilelist[0].free = root->free;  
  122.     openfilelist[0].dirno = 5;  
  123.     openfilelist[0].diroff = 0;  
  124.     strcpy(openfilelist[0].dir, "\\root\\");  
  125.     openfilelist[0].father = 0;  
  126.     openfilelist[0].count = 0;  
  127.     openfilelist[0].fcbstate = 0;  
  128.     openfilelist[0].topenfile = 1;  
  129.     for(i = 1; i < MAXOPENFILE; i++)  
  130.         openfilelist[i].topenfile = 0;  
  131.     curdir = 0;  
  132.     strcpy(currentdir, "\\root\\");  
  133.     startp = ((block0 *)myvhard)->startblock;  
  134. }  
  135. void my_format()  
  136. {  
  137.     FILE *fp;  
  138.     fat *fat1, *fat2;  
  139.     block0 *blk0;  
  140.     time_t now;  
  141.     struct tm *nowtime;  
  142.     fcb *root;  
  143.     int i;  
  144.     blk0 = (block0 *)myvhard;  
  145.     fat1 = (fat *)(myvhard + BLOCKSIZE);  
  146.     fat2 = (fat *)(myvhard + 3 * BLOCKSIZE);  
  147.     root = (fcb *)(myvhard + 5 * BLOCKSIZE);  
  148.     strcpy(blk0->magic, "10101010");  
  149.     strcpy(blk0->information, "My FileSystem Ver 1.0 \n Blocksize=1KB Whole size=1000KB Blocknum=1000 RootBlocknum=2\n");  
  150.     blk0->root = 5;  
  151.     blk0->startblock = (unsigned char *)root;  
  152.     for(i = 0; i < 5; i++)  
  153.     {  
  154.         fat1->id = END;  
  155.         fat2->id = END;  
  156.         fat1++;  
  157.         fat2++;  
  158.     }  
  159.     fat1->id = 6;  
  160.     fat2->id = 6;  
  161.     fat1++;  
  162.     fat2++;  
  163.     fat1->id = END;  
  164.     fat2->id = END;  
  165.     fat1++;  
  166.     fat2++;  
  167.     for(i = 7; i < SIZE / BLOCKSIZE; i++)  
  168.     {  
  169.         fat1->id = FREE;  
  170.         fat2->id = FREE;  
  171.         fat1++;  
  172.         fat2++;  
  173.     }  
  174.     now = time(NULL);  
  175.     nowtime = localtime(&now);  
  176.     strcpy(root->filename, ".");  
  177.     strcpy(root->exname, "");  
  178.     root->attribute = 0x28;  
  179.     root->time = nowtime->tm_hour * 2048 + nowtime->tm_min * 32 + nowtime->tm_sec / 2;  
  180.     root->date = (nowtime->tm_year - 80) * 512 + (nowtime->tm_mon + 1) * 32 + nowtime->tm_mday;  
  181.     root->first = 5;  
  182.     root->length = 2 * sizeof(fcb);  
  183.     root->free = 1;  
  184.     root++;  
  185.     now = time(NULL);  
  186.     nowtime = localtime(&now);  
  187.     strcpy(root->filename, "..");  
  188.     strcpy(root->exname, "");  
  189.     root->attribute = 0x28;  
  190.     root->time = nowtime->tm_hour * 2048 + nowtime->tm_min * 32 + nowtime->tm_sec / 2;  
  191.     root->date = (nowtime->tm_year - 80) * 512 + (nowtime->tm_mon + 1) * 32 + nowtime->tm_mday;  
  192.     root->first = 5;  
  193.     root->length = 2 * sizeof(fcb);  
  194.     root->free = 1;  
  195.     fp = fopen(myfilename, "w");  
  196.     fwrite(myvhard, SIZE, 1, fp);  
  197.     fclose(fp);  
  198. }  
  199. void my_cd(char *dirname)  
  200. {  
  201.     char *dir;  
  202.     int fd;  
  203.     dir = strtok(dirname, "\\");//分解字符串为一组字符串。dirname为要分解的字符串，"\\"为分隔符字符串  
  204.     if(strcmp(dir, ".") == 0)  
  205.         return;  
  206.     else if(strcmp(dir, "..") == 0)  
  207.     {  
  208.         if(curdir)  
  209.             curdir = my_close(curdir);  
  210.         return;  
  211.     }  
  212.     else if(strcmp(dir, "root") == 0)  
  213.     {  
  214.         while(curdir)  
  215.             curdir = my_close(curdir);  
  216.         dir = strtok(NULL, "\\");  
  217.     }  
  218.     while(dir)  
  219.     {  
  220.         fd = my_open(dir);  
  221.         if(fd != -1)  
  222.             curdir = fd;  
  223.         else  
  224.             return;  
  225.         dir = strtok(NULL, "\\");  
  226.     }  
  227. }  
  228. void my_mkdir(char *dirname)  
  229. {  
  230.     fcb *fcbptr;  
  231.     fat *fat1, *fat2;  
  232.     time_t now;  
  233.     struct tm *nowtime;  
  234.     char text[MAXTEXT];  
  235.     unsigned short blkno;  
  236.     int rbn, fd, i;  
  237.     fat1 = (fat *)(myvhard + BLOCKSIZE);  
  238.     fat2 = (fat *)(myvhard + 3 * BLOCKSIZE);  
  239.     openfilelist[curdir].count = 0;  
  240.     rbn = do_read(curdir, openfilelist[curdir].length, text);  
  241.     fcbptr = (fcb *)text;  
  242.     for(i = 0; i < rbn / sizeof(fcb); i++)//在当前目录下找，是否有重名目录  
  243.     {  
  244.         if(strcmp(fcbptr->filename, dirname) == 0 && strcmp(fcbptr->exname, "") == 0)  
  245.         {  
  246.             printf("Error,the dirname is already exist!\n");  
  247.             return;  
  248.         }  
  249.         fcbptr++;  
  250.     }  
  251.     fcbptr = (fcb *)text;  
  252.     for(i = 0; i < rbn / sizeof(fcb); i++)  
  253.     {  
  254.         if(fcbptr->free == 0)  
  255.             break;  
  256.         fcbptr++;  
  257.     }  
  258.     blkno = findblock();//寻找空闲盘块  
  259.     if(blkno == -1)  
  260.         return;  
  261.     (fat1 + blkno)->id = END;  
  262.     (fat2 + blkno)->id = END;  
  263.     now = time(NULL);  
  264.     nowtime = localtime(&now);  
  265.     strcpy(fcbptr->filename, dirname);  
  266.     strcpy(fcbptr->exname, "");  
  267.     fcbptr->attribute = 0x30;  
  268.     fcbptr->time = nowtime->tm_hour * 2048 + nowtime->tm_min * 32 + nowtime->tm_sec / 2;  
  269.     fcbptr->date = (nowtime->tm_year - 80) * 512 + (nowtime->tm_mon + 1) * 32 + nowtime->tm_mday;  
  270.     fcbptr->first = blkno;  
  271.     fcbptr->length = 2 * sizeof(fcb);  
  272.     fcbptr->free = 1;  
  273.     openfilelist[curdir].count = i * sizeof(fcb);  
  274.     do_write(curdir, (char *)fcbptr, sizeof(fcb), 2);  
  275.   
  276.     fd = my_open(dirname);//建立新目录的'.','..'目录  
  277.     if(fd == -1)  
  278.         return;  
  279.     fcbptr = (fcb *)malloc(sizeof(fcb));  
  280.     now = time(NULL);  
  281.     nowtime = localtime(&now);  
  282.     strcpy(fcbptr->filename, ".");  
  283.     strcpy(fcbptr->exname, "");  
  284.     fcbptr->attribute = 0x28;  
  285.     fcbptr->time = nowtime->tm_hour * 2048 + nowtime->tm_min * 32 + nowtime->tm_sec / 2;  
  286.     fcbptr->date = (nowtime->tm_year - 80) * 512 + (nowtime->tm_mon + 1) * 32 + nowtime->tm_mday;  
  287.     fcbptr->first = blkno;  
  288.     fcbptr->length = 2 * sizeof(fcb);  
  289.     fcbptr->free = 1;  
  290.     do_write(fd, (char *)fcbptr, sizeof(fcb), 2);  
  291.     now = time(NULL);  
  292.     nowtime = localtime(&now);  
  293.     strcpy(fcbptr->filename, "..");  
  294.     strcpy(fcbptr->exname, "");  
  295.     fcbptr->attribute = 0x28;  
  296.     fcbptr->time = nowtime->tm_hour * 2048 + nowtime->tm_min * 32 + nowtime->tm_sec / 2;  
  297.     fcbptr->date = (nowtime->tm_year - 80) * 512 + (nowtime->tm_mon + 1) * 32 + nowtime->tm_mday;  
  298.     fcbptr->first = blkno;  
  299.     fcbptr->length = 2 * sizeof(fcb);  
  300.     fcbptr->free = 1;  
  301.     do_write(fd, (char *)fcbptr, sizeof(fcb), 2);  
  302.     free(fcbptr);  
  303.     my_close(fd);  
  304.   
  305.     fcbptr = (fcb *)text;  
  306.     fcbptr->length = openfilelist[curdir].length;  
  307.     openfilelist[curdir].count = 0;  
  308.     do_write(curdir, (char *)fcbptr, sizeof(fcb), 2);  
  309.     openfilelist[curdir].fcbstate = 1;  
  310. }  
  311.   
  312. void my_rmdir(char *dirname)  
  313. {  
  314.     fcb *fcbptr,*fcbptr2;  
  315.     fat *fat1, *fat2, *fatptr1, *fatptr2;  
  316.     char text[MAXTEXT], text2[MAXTEXT];  
  317.     unsigned short blkno;  
  318.     int rbn, rbn2, fd, i, j;  
  319.     fat1 = (fat *)(myvhard + BLOCKSIZE);  
  320.     fat2 = (fat *)(myvhard + 3 * BLOCKSIZE);  
  321.     if(strcmp(dirname, ".") == 0 || strcmp(dirname, "..") == 0)  
  322.     {  
  323.         printf("Error,can't remove this directory.\n");  
  324.         return;  
  325.     }  
  326.     openfilelist[curdir].count = 0;  
  327.     rbn = do_read(curdir, openfilelist[curdir].length, text);  
  328.     fcbptr = (fcb *)text;  
  329.     for(i = 0; i < rbn / sizeof(fcb); i++)//查找要删除的目录  
  330.     {  
  331.         if(strcmp(fcbptr->filename, dirname) == 0 && strcmp(fcbptr->exname, "") == 0)  
  332.             break;  
  333.         fcbptr++;  
  334.     }  
  335.     if(i == rbn / sizeof(fcb))  
  336.     {  
  337.         printf("Error,the directory is not exist.\n");  
  338.         return;  
  339.     }  
  340.     fd = my_open(dirname);  
  341.     rbn2 = do_read(fd, openfilelist[fd].length, text2);  
  342.     fcbptr2 = (fcb *)text2;  
  343.     for(j = 0; j < rbn2 / sizeof(fcb); j++)//判断要删除目录是否为空  
  344.     {  
  345.         if(strcmp(fcbptr2->filename, ".") && strcmp(fcbptr2->filename, "..") && strcmp(fcbptr2->filename, ""))  
  346.         {  
  347.             my_close(fd);  
  348.             printf("Error,the directory is not empty.\n");  
  349.             return;  
  350.         }  
  351.         fcbptr2++;  
  352.     }  
  353.     blkno = openfilelist[fd].first;  
  354.     while(blkno != END)  
  355.     {  
  356.         fatptr1 = fat1 + blkno;  
  357.         fatptr2 = fat2 + blkno;  
  358.         blkno = fatptr1->id;  
  359.         fatptr1->id = FREE;  
  360.         fatptr2->id = FREE;  
  361.     }  
  362.     my_close(fd);  
  363.     strcpy(fcbptr->filename, "");  
  364.     fcbptr->free = 0;  
  365.     openfilelist[curdir].count = i * sizeof(fcb);  
  366.     do_write(curdir, (char *)fcbptr, sizeof(fcb), 2);  
  367.     openfilelist[curdir].fcbstate = 1;  
  368. }  
  369. void my_ls()  
  370. {  
  371.     fcb *fcbptr;  
  372.     char text[MAXTEXT];  
  373.     int rbn, i;  
  374.     openfilelist[curdir].count = 0;  
  375.     rbn = do_read(curdir, openfilelist[curdir].length, text);  
  376.     fcbptr = (fcb *)text;  
  377.     for(i = 0; i < rbn / sizeof(fcb); i++)  
  378.     {  
  379.         if(fcbptr->free)  
  380.         {  
  381.             if(fcbptr->attribute & 0x20)  
  382.                 printf("%s\\\t\t<DIR>\t\t%d/%d/%d\t%02d:%02d:%02d\n", fcbptr->filename, (fcbptr->date >> 9) + 1980, (fcbptr->date >> 5) & 0x000f, fcbptr->date & 0x001f, fcbptr->time >> 11, (fcbptr->time >> 5) & 0x003f, fcbptr->time & 0x001f * 2);  
  383.             else  
  384.                 printf("%s.%s\t\t%dB\t\t%d/%d/%d\t%02d:%02d:%02d\t\n", fcbptr->filename, fcbptr->exname, (int)(fcbptr->length), (fcbptr->date >> 9) + 1980, (fcbptr->date >> 5) & 0x000f, fcbptr->date & 0x1f, fcbptr->time >> 11, (fcbptr->time >> 5) & 0x3f, fcbptr->time & 0x1f * 2);  
  385.         }  
  386.         fcbptr++;  
  387.     }  
  388. }  
  389. void my_create(char *filename)  
  390. {  
  391.     fcb *fcbptr;  
  392.     fat *fat1, *fat2;  
  393.     char *fname, *exname, text[MAXTEXT];  
  394.     unsigned short blkno;  
  395.     int rbn, i;  
  396.     time_t now;  
  397.     struct tm *nowtime;  
  398.     fat1 = (fat *)(myvhard + BLOCKSIZE);  
  399.     fat2 = (fat *)(myvhard + BLOCKSIZE);  
  400.     fname = strtok(filename, ".");  
  401.     exname = strtok(NULL, ".");  
  402.     if(strcmp(fname, "") == 0)  
  403.     {  
  404.         printf("Error,creating file must have a right name.\n");  
  405.         return;  
  406.     }  
  407.     if(!exname)  
  408.     {  
  409.         printf("Error,creating file must have a extern name.\n");  
  410.         return;  
  411.     }  
  412.     openfilelist[curdir].count = 0;  
  413.     rbn = do_read(curdir, openfilelist[curdir].length, text);  
  414.     fcbptr = (fcb *)text;  
  415.     for(i = 0; i < rbn / sizeof(fcb); i++)  
  416.     {  
  417.         if(strcmp(fcbptr->filename, fname) == 0 && strcmp(fcbptr->exname, exname) == 0)  
  418.         {  
  419.             printf("Error,the filename is already exist!\n");  
  420.             return;  
  421.         }  
  422.         fcbptr++;  
  423.     }  
  424.     fcbptr = (fcb *)text;  
  425.     for(i = 0; i < rbn / sizeof(fcb); i++)  
  426.     {  
  427.         if(fcbptr->free == 0)  
  428.             break;  
  429.         fcbptr++;  
  430.     }  
  431.     blkno = findblock();  
  432.     if(blkno == -1)  
  433.         return;  
  434.     (fat1 + blkno)->id = END;  
  435.     (fat2 + blkno)->id = END;  
  436.   
  437.     now = time(NULL);  
  438.     nowtime = localtime(&now);  
  439.     strcpy(fcbptr->filename, fname);  
  440.     strcpy(fcbptr->exname, exname);  
  441.     fcbptr->attribute = 0x00;  
  442.     fcbptr->time = nowtime->tm_hour * 2048 + nowtime->tm_min * 32 + nowtime->tm_sec / 2;  
  443.     fcbptr->date = (nowtime->tm_year - 80) * 512 + (nowtime->tm_mon + 1) * 32 + nowtime->tm_mday;  
  444.     fcbptr->first = blkno;  
  445.     fcbptr->length = 0;  
  446.     fcbptr->free = 1;  
  447.     openfilelist[curdir].count = i * sizeof(fcb);  
  448.     do_write(curdir, (char *)fcbptr, sizeof(fcb), 2);  
  449.     fcbptr = (fcb *)text;  
  450.     fcbptr->length = openfilelist[curdir].length;  
  451.     openfilelist[curdir].count = 0;  
  452.     do_write(curdir, (char *)fcbptr, sizeof(fcb), 2);  
  453.     openfilelist[curdir].fcbstate = 1;  
  454. }  
  455. void my_rm(char *filename)  
  456. {  
  457.     fcb *fcbptr;  
  458.     fat *fat1, *fat2, *fatptr1, *fatptr2;  
  459.     char *fname, *exname, text[MAXTEXT];  
  460.     unsigned short blkno;  
  461.     int rbn, i;  
  462.     fat1 = (fat *)(myvhard + BLOCKSIZE);  
  463.     fat2 = (fat *)(myvhard + 3 * BLOCKSIZE);  
  464.     fname = strtok(filename, ".");  
  465.     exname = strtok(NULL, ".");  
  466.     if(strcmp(fname, "") == 0)  
  467.     {  
  468.         printf("Error,removing file must have a right name.\n");  
  469.         return;  
  470.     }  
  471.     if(!exname)  
  472.     {  
  473.         printf("Error,removing file must have a extern name.\n");  
  474.         return;  
  475.     }  
  476.     openfilelist[curdir].count = 0;  
  477.     rbn = do_read(curdir, openfilelist[curdir].length, text);  
  478.     fcbptr = (fcb *)text;  
  479.     for(i = 0; i < rbn / sizeof(fcb); i++)  
  480.     {  
  481.         if(strcmp(fcbptr->filename, fname) == 0 && strcmp(fcbptr->exname, exname) == 0)  
  482.             break;  
  483.         fcbptr++;  
  484.     }  
  485.     if(i == rbn / sizeof(fcb))  
  486.     {  
  487.         printf("Error,the file is not exist.\n");  
  488.         return;  
  489.     }  
  490.     openfilelist[curdir].count = 0;  
  491.     rbn = do_read(curdir, openfilelist[curdir].length, text);  
  492.     fcbptr = (fcb *)text;  
  493.     for(i = 0; i < rbn / sizeof(fcb); i++)  
  494.     {  
  495.         if(strcmp(fcbptr->filename, fname) == 0 && strcmp(fcbptr->exname, exname) == 0)  
  496.             break;  
  497.         fcbptr++;  
  498.     }  
  499.     if(i == rbn / sizeof(fcb))  
  500.     {  
  501.         printf("Error,the file is not exist.\n");  
  502.         return;  
  503.     }  
  504.     blkno = fcbptr->first;  
  505.     while(blkno != END)  
  506.     {  
  507.         fatptr1 = fat1 + blkno;  
  508.         fatptr2 = fat2 + blkno;  
  509.         blkno = fatptr1->id;  
  510.         fatptr1->id = FREE;  
  511.         fatptr2->id = FREE;  
  512.     }  
  513.     strcpy(fcbptr->filename, "");  
  514.     fcbptr->free = 0;  
  515.     openfilelist[curdir].count = i * sizeof(fcb);  
  516.     do_write(curdir, (char *)fcbptr, sizeof(fcb), 2);  
  517.     openfilelist[curdir].fcbstate = 1;  
  518. }  
  519. int my_open(char *filename)  
  520. {  
  521.     fcb *fcbptr;  
  522.     char *fname, exname[3], *str, text[MAXTEXT];  
  523.     int rbn, fd, i;  
  524.     fname = strtok(filename, ".");  
  525.     str = strtok(NULL, ".");  
  526.     if(str)  
  527.         strcpy(exname, str);  
  528.     else  
  529.         strcpy(exname, "");  
  530.     for(i = 0; i < MAXOPENFILE; i++)  
  531.     {  
  532.         if(strcmp(openfilelist[i].filename, fname) == 0 && strcmp(openfilelist[i].exname, exname) == 0 && i != curdir)  
  533.         {  
  534.             printf("Error,the file is already open.\n");  
  535.             return -1;  
  536.         }  
  537.     }  
  538.     openfilelist[curdir].count = 0;  
  539.     rbn = do_read(curdir, openfilelist[curdir].length, text);  
  540.     fcbptr = (fcb *)text;  
  541.     for(i = 0; i < rbn / sizeof(fcb); i++)  
  542.     {  
  543.         if(strcmp(fcbptr->filename, fname) == 0 && strcmp(fcbptr->exname, exname) == 0)  
  544.             break;  
  545.         fcbptr++;  
  546.     }  
  547.     if(i == rbn / sizeof(fcb))  
  548.     {  
  549.         printf("Error,the file is not exist.\n");  
  550.         return -1;  
  551.     }  
  552.     fd = findopenfile();  
  553.     if(fd == -1)  
  554.         return -1;  
  555.     strcpy(openfilelist[fd].filename, fcbptr->filename);  
  556.     strcpy(openfilelist[fd].exname, fcbptr->exname);  
  557.     openfilelist[fd].attribute = fcbptr->attribute;  
  558.     openfilelist[fd].time = fcbptr->time;  
  559.     openfilelist[fd].date = fcbptr->date;  
  560.     openfilelist[fd].first = fcbptr->first;  
  561.     openfilelist[fd].length = fcbptr->length;  
  562.     openfilelist[fd].free = fcbptr->free;  
  563.     openfilelist[fd].dirno = openfilelist[curdir].first;  
  564.     openfilelist[fd].diroff = i;  
  565.     strcpy(openfilelist[fd].dir, openfilelist[curdir].dir);  
  566.     strcat(openfilelist[fd].dir, filename);  
  567.     if(fcbptr->attribute & 0x20)  
  568.         strcat(openfilelist[fd].dir, "\\");  
  569.     openfilelist[fd].father = curdir;  
  570.     openfilelist[fd].count = 0;  
  571.     openfilelist[fd].fcbstate = 0;  
  572.     openfilelist[fd].topenfile = 1;  
  573.     return fd;  
  574. }  
  575. int my_close(int fd)  
  576. {  
  577.     fcb *fcbptr;  
  578.     int father;  
  579.     if(fd < 0 || fd >= MAXOPENFILE)  
  580.     {  
  581.         printf("Error,the file is not exist.\n");  
  582.         return -1;  
  583.     }  
  584.     if(openfilelist[fd].fcbstate)  
  585.     {  
  586.         fcbptr = (fcb *)malloc(sizeof(fcb));  
  587.         strcpy(fcbptr->filename, openfilelist[fd].filename);  
  588.         strcpy(fcbptr->exname, openfilelist[fd].exname);  
  589.         fcbptr->attribute = openfilelist[fd].attribute;  
  590.         fcbptr->time = openfilelist[fd].time;  
  591.         fcbptr->date = openfilelist[fd].date;  
  592.         fcbptr->first = openfilelist[fd].first;  
  593.         fcbptr->length = openfilelist[fd].length;  
  594.         fcbptr->free = openfilelist[fd].free;  
  595.         father = openfilelist[fd].father;  
  596.         openfilelist[father].count = openfilelist[fd].diroff * sizeof(fcb);  
  597.         do_write(father, (char *)fcbptr, sizeof(fcb), 2);  
  598.         free(fcbptr);  
  599.         openfilelist[fd].fcbstate = 0;  
  600.     }  
  601.     strcpy(openfilelist[fd].filename, "");  
  602.     strcpy(openfilelist[fd].exname, "");  
  603.     openfilelist[fd].topenfile = 0;  
  604.     return father;  
  605. }  
  606. int my_write(int fd)  
  607. {  
  608.     fat *fat1, *fat2, *fatptr1, *fatptr2;  
  609.     int wstyle, len, ll, tmp;  
  610.     char text[MAXTEXT];  
  611.     unsigned short blkno;  
  612.     fat1 = (fat *)(myvhard + BLOCKSIZE);  
  613.     fat2 = (fat *)(myvhard + 3 * BLOCKSIZE);  
  614.     if(fd < 0 || fd >= MAXOPENFILE)  
  615.     {  
  616.         printf("The file is not exist!\n");  
  617.         return -1;  
  618.     }  
  619.     while(1)  
  620.     {  
  621.         printf("Please enter the number of write style:\n1.cut write\t2.cover write\t3.add write\n");  
  622.         scanf("%d", &wstyle);  
  623.         if(wstyle > 0 && wstyle < 4)  
  624.             break;  
  625.         printf("Input Error!");  
  626.     }  
  627.     getchar();  
  628.     switch(wstyle)  
  629.     {  
  630.         case 1:  
  631.             blkno = openfilelist[fd].first;  
  632.             fatptr1 = fat1 + blkno;  
  633.             fatptr2 = fat2 + blkno;  
  634.             blkno = fatptr1->id;  
  635.             fatptr1->id = END;  
  636.             fatptr2->id = END;  
  637.             while(blkno != END)  
  638.             {  
  639.                 fatptr1 = fat1 + blkno;  
  640.                 fatptr2 = fat2 + blkno;  
  641.                 blkno = fatptr1->id;  
  642.                 fatptr1->id = FREE;  
  643.                 fatptr2->id = FREE;  
  644.             }  
  645.             openfilelist[fd].count = 0;  
  646.             openfilelist[fd].length = 0;  
  647.             break;  
  648.         case 2:  
  649.             openfilelist[fd].count = 0;  
  650.             break;  
  651.         case 3:  
  652.             openfilelist[fd].count = openfilelist[fd].length;  
  653.             break;  
  654.         default:  
  655.             break;  
  656.     }  
  657.     ll = 0;  
  658.     printf("please input write data(end with Ctrl+Z):\n");  
  659.     while(gets(text))  
  660.     {  
  661.         len = strlen(text);  
  662.         text[len++] = '\n';  
  663.         text[len] = '\0';  
  664.         tmp = do_write(fd, text, len, wstyle);  
  665.         if(tmp != -1)  
  666.             ll += tmp;  
  667.         if(tmp < len)  
  668.         {  
  669.             printf("Wirte Error!");  
  670.             break;  
  671.         }  
  672.     }  
  673.     return ll;  
  674. }  
  675.   
  676. int do_write(int fd, char *text, int len, char wstyle)  
  677. {  
  678.     fat *fat1, *fat2, *fatptr1, *fatptr2;  
  679.     unsigned char *buf, *blkptr;  
  680.     unsigned short blkno, blkoff;  
  681.     int i, ll;  
  682.     fat1 = (fat *)(myvhard + BLOCKSIZE);  
  683.     fat2 = (fat *)(myvhard + 3 * BLOCKSIZE);  
  684.     buf = (unsigned char *)malloc(BLOCKSIZE);  
  685.     if(buf == NULL)  
  686.     {  
  687.         printf("malloc failed!\n");  
  688.         return -1;  
  689.     }  
  690.     blkno = openfilelist[fd].first;  
  691.     blkoff = openfilelist[fd].count;  
  692.     fatptr1 = fat1 + blkno;  
  693.     fatptr2 = fat2 + blkno;  
  694.     while(blkoff >= BLOCKSIZE)  
  695.     {  
  696.         blkno = fatptr1->id;  
  697.         if(blkno == END)  
  698.         {  
  699.             blkno = findblock();  
  700.             if(blkno == -1)  
  701.             {  
  702.                 free(buf);  
  703.                 return -1;  
  704.             }  
  705.             fatptr1->id = blkno;  
  706.             fatptr2->id = blkno;  
  707.             fatptr1 = fat1 + blkno;  
  708.             fatptr2 = fat2 + blkno;  
  709.             fatptr1->id = END;  
  710.             fatptr2->id = END;  
  711.         }  
  712.         else  
  713.         {  
  714.             fatptr1 = fat1 + blkno;  
  715.             fatptr2 = fat2 + blkno;  
  716.         }  
  717.         blkoff = blkoff - BLOCKSIZE;  
  718.     }  
  719.   
  720.     ll = 0;  
  721.     while(ll < len)  
  722.     {  
  723.         blkptr = (unsigned char *)(myvhard + blkno * BLOCKSIZE);  
  724.         for(i = 0; i < BLOCKSIZE; i++)  
  725.             buf[i] = blkptr[i];  
  726.         for(;blkoff < BLOCKSIZE; blkoff++)  
  727.         {  
  728.             buf[blkoff] = text[ll++];  
  729.             openfilelist[fd].count++;  
  730.             if(ll == len)  
  731.                 break;  
  732.         }  
  733.         for(i = 0; i < BLOCKSIZE; i++)  
  734.             blkptr[i] = buf[i];  
  735.         if(ll < len)  
  736.         {  
  737.             blkno = fatptr1->id;  
  738.             if(blkno == END)  
  739.             {  
  740.                 blkno = findblock();  
  741.                 if(blkno == -1)  
  742.                     break;  
  743.                 fatptr1->id = blkno;  
  744.                 fatptr2->id = blkno;  
  745.                 fatptr1 = fat1 + blkno;  
  746.                 fatptr2 = fat2 + blkno;  
  747.                 fatptr1->id = END;  
  748.                 fatptr2->id = END;  
  749.             }  
  750.             else  
  751.             {  
  752.                 fatptr1 = fat1 + blkno;  
  753.                 fatptr2 = fat2 + blkno;  
  754.             }  
  755.             blkoff = 0;  
  756.             }  
  757.     }  
  758.     if(openfilelist[fd].count > openfilelist[fd].length)  
  759.         openfilelist[fd].length = openfilelist[fd].count;  
  760.     openfilelist[fd].fcbstate = 1;  
  761.     free(buf);  
  762.     return ll;  
  763. }  
  764. int my_read(int fd, int len)  
  765. {  
  766.     char text[MAXTEXT];  
  767.     int ll;  
  768.     if(fd < 0 || fd >= MAXOPENFILE)  
  769.     {  
  770.         printf("The File is not exist!\n");  
  771.         return -1;  
  772.     }  
  773.     openfilelist[fd].count = 0;  
  774.     ll = do_read(fd, len, text);  
  775.     if(ll != -1)  
  776.         printf("%s", text);  
  777.     else  
  778.         printf("Read Error!\n");  
  779.     return ll;  
  780. }  
  781. int do_read(int fd, int len, char *text)  
  782. {  
  783.     fat *fat1, *fatptr;  
  784.     unsigned char *buf, *blkptr;  
  785.     unsigned short blkno, blkoff;  
  786.     int i, ll;  
  787.     fat1 = (fat *)(myvhard + BLOCKSIZE);  
  788.     buf = (unsigned char *)malloc(BLOCKSIZE);  
  789.     if(buf == NULL)  
  790.     {  
  791.         printf("malloc failed!\n");  
  792.         return -1;  
  793.     }  
  794.     blkno = openfilelist[fd].first;  
  795.     blkoff = openfilelist[fd].count;  
  796.     if(blkoff >= openfilelist[fd].length)  
  797.     {  
  798.         puts("Read out of range!");  
  799.         free(buf);  
  800.         return -1;  
  801.     }  
  802.     fatptr = fat1 + blkno;  
  803.     while(blkoff >= BLOCKSIZE)  
  804.     {  
  805.         blkno = fatptr->id;  
  806.         blkoff = blkoff - BLOCKSIZE;  
  807.         fatptr = fat1 + blkno;  
  808.     }  
  809.     ll = 0;  
  810.     while(ll < len)  
  811.     {  
  812.         blkptr = (unsigned char *)(myvhard + blkno * BLOCKSIZE);  
  813.         for(i = 0; i < BLOCKSIZE; i++)  
  814.             buf[i] = blkptr[i];  
  815.         for(; blkoff < BLOCKSIZE; blkoff++)  
  816.         {  
  817.             text[ll++] = buf[blkoff];  
  818.             openfilelist[fd].count++;  
  819.             if(ll == len || openfilelist[fd].count == openfilelist[fd].length)  
  820.                 break;  
  821.         }  
  822.         if(ll < len && openfilelist[fd].count != openfilelist[fd].length)  
  823.         {  
  824.             blkno = fatptr->id;  
  825.             if(blkno == END)  
  826.                 break;  
  827.             blkoff = 0;  
  828.             fatptr = fat1 + blkno;  
  829.         }  
  830.     }  
  831.     text[ll] = '\0';  
  832.     free(buf);  
  833.     return ll;  
  834. }  
  835. void my_exitsys()  
  836. {  
  837.     FILE *fp;  
  838.     while(curdir)  
  839.         curdir = my_

鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
如何用C#动态创建XML文件并保存至指定路径发布时间：2022-07-14
下一篇：
c#贪吃蛇小游戏发布时间：2022-07-14
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap