操作系统课程设计实验报告

学    部：

专业班级：

姓    名：

学    号：

指导教师：

摘要

目录

1、概论    

2、系统设计   

3、系统实现

4、系统测试

5、结论

参考文献

附件

摘要

操作系统是计算机学科的核心课程，对于计算机科学与技术专业的学生尤为重要。此次课程设计旨在加强我们对操作系统中文件系统的理解。结合过去所学知识，为此设计了一个简单的Linux下的运行的文件管理系统。

1、概论

    文件系统是硬盘上文件存储和读取的系统架构。操作系统必须在硬盘上建立文件系统，才能进行文件和文件夹的读取和存盘。在Linux中常见的文件系统有ext2、ext3、ext4和swap等。其中swap用于虚拟存盘，而其他文件系统用于一般的挂载目录。

文件系统是系统对文件和目录的一种定位方式，从而能让系统快速的找到该文件。对于使用者而言，文件系统并没有意义，只需将文件分类放置于不同的文件夹中即可。

2、系统设计

设计内容：

编写程序模拟实现一个简单的文件管理系统，设计一个较实用的用户界面，方便用户使用。

设计要求：

提供以下相关文件操作：

（1）login：登录

（2）register：注册

（3）open：打开文件

（4）read：读取文件数据到屏幕

（5）write：写文件，分为cover和append两种类型;cover是覆盖原数据，append是在不改变原始数据的基础上进行增加。

（6）close：关闭文件

（7）create：新增文件

（8）delete：删除文件

（9）exit：退出程序

（10）dir：列文件目录

（11）help：帮助

3、系统实现

注册登录模块实现：

帮助模块实现：

列文件目录，新增文件模块实现：

打开、读、写文件模块实现：

关闭文件模块实现：

删除、退出文件模块实现：

4、系统测试

  （1）实验环境

   操作系统Ubuntu 15.10

   编译器：  gcc

   语言：C语言

  （2）测试结果

       编译通过，但有警告，运行成功。

5、小结

通过这一次计算机操作系统的上机实验，使我对不同环境下的操作系统有了进一步的了解，使我学到了很多关于Linux的操作和相关知识。在程序编译过程中遇到了不少的问题，通过查阅书籍、网上浏览、质询老师同学并最终解决问题，这个过程是痛苦的，但问题解决之后又会获得无限的快乐。并且在解决问题的过程中收获了许多从前不曾了解的知识，从而也知道了自己的弱点所在。因此在以后的学习中需要更加努力。

参考文献

《计算机操作系统（第2版）》庞丽萍 阳富民 编著

《计算机操作系统实验指导（Linux版）》郑然 庞丽萍 编著

《精通Linux C编程》程国钢 编著

《Ubuntu Linux 从入门到精通》丰士昌 编著

附件

源程序

#include<string.h>

#include<stdio.h>

#include<stdlib.h>

#include<stdbool.h>

#define MAX_BLOCKS_NUM 256     

#define MAX_BLOCK_SIZE 1025      

#define MAX_DATANODE_NUM 2      

#define MAX_INODE_NUM  512       

#define MAX_CACHE_NUM 32        

typedef struct user{

     char account[15];                  

     char password[15];      }user;

typedef struct datanode       {

     int num;                

     int begin;                

     int end;    }datanode;

typedef struct inode{

     char filename[30];

     int num;

     char code[30];      

     int size;

     datanode fat[MAX_DATANODE_NUM];

     int node_num;}inode;

typedef struct dirEntry{

     inode ind;

     struct dirEntry *next;}dirEntry;

typedef struct block {

     char content[MAX_BLOCK_SIZE];         

     int num;

     bool isRevised;                        

     int offset;   }block;

int islogin = 0;     

char blockspath[30] = "userdata/blocksDISK.disk";

char userspath[30] = "userdata/users.us";

static user currUser;            

static dirEntry *DIR;

static int curr_inode_num = 0;              

static block *cache;

int max_node = 0;           

static int FBT[MAX_BLOCKS_NUM];

static char *dirpath;

static char fbtpath[30] = "userdata/FBT.disk";

static dirEntry* selectEntry;     

static dirEntry* currEntry;

static char cm_help[10] = "help";

static char cm_lg[10] = "login";

static char cm_rg[10] = "register";

static char cm_dir[10] = "dir";

static char cm_create[10] = "create";

static char cm_delete[10] = "delete";

static char cm_open[10] = "open";

static char cm_read[10] = "read";

static char cm_write[10] = "write";

static char cm_close[10] = "close";

static char cm_exit[10] = "exit";

static char cm_cancle[10] = "cancle";

void createStyle(int,char);

void createWrap(int);

int createSystem();

int diskUpdate(block);

void start();

void getUser();

int login();

int regist();

char lgOrRg();

void createBlocksDisk();

FILE* createDir();

void initDir(char *);

int getAction();

void initFBT();                

int getCode();

int getFreeBlock(bool);

void saveDir();

void saveBlock(block bk);

void saveFBT();

int createHelp(char *filename);

dirEntry* delHelp(char *filename);

void createDataDir();

int LgRg();                    

void help();

void dir();

void create();

void del();

void open();

void close();

void read();

void write();

void coverHelp();

void appendHelp();

int strcmpi(char *p1, char *p2){

     if(strlen(p1)!=strlen(p2))  { return -1; }

     int i;

     for(i=0; i<strlen(p1); i++)

     { if(p1[i]!=p2[i])

          {return -1;}}

     return 0;}

void createDataDir(){

     char *datapath = "userdata";

     printf("No dataDir !\nNow create it ...\n");

     if(mkdir(datapath,0777))    {

          printf("Can not create DataDir ...\nCrtl+C to exit.\n");

          while(1); }

     printf("Succeed creating dataDir !\n");}

void showInode(inode ind){

     printf("num: %d\n",ind.num);

     printf("filename: %s\n",ind.filename);

     printf("size: %d\n",ind.size);}

void createStyle(int num, char style){

     while(num--)  { printf("%c", style); }}

void createWrap(int n){

     while(n--)    { printf("\n");}}

char lgOrRg(){

     while(1) {

          char com[10];

          printf("[login] or [register]: ");

          scanf("%s",com);

          if(!strcmpi(com,cm_lg))      {

               return 'l';        }

          if(!strcmp(com, cm_rg))

          {              return 'r';}}}

          }void help(){

     printf("欢迎您使用文件模拟系统 ");

     printf("以下是本系统支持的指令:\n");

     printf("exit : 退出\n");

     printf("help : 帮助\n");

     printf("dir : 查看目录中的所有文件\n");

     printf("create : 新建文件\n");

     printf("delete : 删除文件\n");

     printf("open : 打开文件\n");

     printf("read : 读文件\n");

     printf("write : 写文件\n");

     printf("close : 关闭文件\n");}

void createBlocksDisk(){

     FILE* fp = fopen(blockspath, "w");

     if(fp==NULL)  {

          printf("Can not create Disk !\nCtrl+C to quit\n");

          while(1); }

     else {

          int i, j;

          for(i=0; i<MAX_BLOCKS_NUM; i++)       {

               for(j=0; j<MAX_BLOCK_SIZE; j++)            {

                    fputc('$',fp);               }         }

          fclose(fp);   }

     FILE *p = fopen(fbtpath, "w");

     if(p==NULL)   {

          printf("FBT Created ERROR !\n");

          while(1); }

     else {

          int i;

          for(i = 0; i<MAX_BLOCKS_NUM; i++)         {

               FBT[i] = 0;

               fprintf(p," %d",0);         }

          fclose(p);    }}

dirEntry* isInDir(char *filename) {

     int i;

     dirEntry *pt = DIR;

     while(pt!=NULL)    {

          if(!strcmpi(pt->ind.filename, filename))       {

               return pt;         }

          pt = pt->next;     }

     return NULL;}

dirEntry* delHelp(char* filename){

     dirEntry* res = DIR;

     if(res==NULL) {

          printf("No files !\n");

          return res;   }

     if(res->next==NULL)    {

          if(!strcmpi(res->ind.filename,filename))       {

               DIR = NULL;

               currEntry=NULL;

               printf("删除成功!\n");

               return res;        }

          else      {

               return NULL;       }    }

     if(!strcmpi(res->ind.filename,filename))  {

          DIR = res->next;

          printf("删除成功!\n");

          return res;   }

     while(res->next!=NULL) {

          if(!strcmpi(res->next->ind.filename,filename))      {

               dirEntry* r = res->next;

               res->next = r->next;

               printf("删除成功!\n");

               return r;      }

          res = res->next;   }

     printf("删除失败!\n");

     return NULL;}

void coverHelp(){

     int f;

     if(selectEntry->ind.size!=0){

          for(f=0; f<selectEntry->ind.node_num; f++)          {

               FBT[selectEntry->ind.fat[f].num]==0;      }    }

     char content[MAX_DATANODE_NUM][MAX_BLOCK_SIZE];

     char tmp;

     inode ind;

     printf("End with '$'\n");

     int i = 0;

     while((tmp=getchar())!='$') {

          if(i==0&&tmp=='\n')         {

               continue;      }

          content[i/MAX_BLOCK_SIZE][i++] = tmp;     }

     ind.size = i;

     if(i>(MAX_BLOCK_SIZE-1)*MAX_DATANODE_NUM) {

          printf("文件过大，无法存储，创建失败 !\n");

          return;  }

     int k;

     for(k=0; k<=i/(MAX_BLOCK_SIZE-1);k++) {

          block bk;      int bkn;

          for(bkn=0; bkn<MAX_BLOCK_SIZE-1; bkn++)        {

               bk.content[bkn]='$';        }

          bk.content[MAX_BLOCK_SIZE-1]='\0';

          char *tmp;         int tp=0;      int len=0;         if(k==0)      {

               if(i<MAX_BLOCK_SIZE-1)           {

                    len = i;           }         }         if(k==1)      {

               len=i%(MAX_BLOCK_SIZE-1)+1;      }

          for(tp=0; tp<len; tp++)      {

               bk.content[tp] = content[k][tp];      }

          bk.isRevised = true;

          if(k==0)      {

               bk.num = getFreeBlock(false);         }

          else      {

               bk.num = getFreeBlock(true);

               if(bk.num==-1)               {

                    printf("数据块已用完,内存不足!\n");

                    return;            }         }

          saveBlock(bk);

          ind.fat[k].num = bk.num;

          ind.fat[k].begin = 0;

          ind.fat[k].end = len;  }

     ind.node_num = k;

     strcpy(ind.code, selectEntry->ind.code);

     strcpy(ind.filename, selectEntry->ind.filename);

     ind.num = selectEntry->ind.node_num;

     selectEntry->ind = ind;

     saveDir();    saveFBT();

     printf("文件已保存 !\n");}

void appendHelp()

{    char tmp[MAX_BLOCK_SIZE*2];

     char ch;

     printf("End with '$':\n");

     int i = 0;

     while((ch=getchar())!='$')  {

          if(i==0&&ch=='\n')      {

               continue;      }

          tmp[i++] = ch;     }

     tmp[i]='\0';

     if((i+selectEntry->ind.size)>(MAX_BLOCK_SIZE-1)*MAX_DATANODE_NUM) {

          printf("文件过大，无法存储，创建失败 !\n");

          return; }

     else {

          if(selectEntry->ind.size>MAX_BLOCK_SIZE-1)          {

               int offset = selectEntry->ind.size - MAX_BLOCK_SIZE + 1;

               FILE* bfp = fopen(blockspath,"r+");

               if(bfp==NULL)           {

                    printf("DISK ERROR !\nFrom appendFile ...\n");

                    return;            }

               else           {    fseek(bfp,(selectEntry->ind.fat[1].num*(MAX_BLOCK_SIZE-1)+offset),SEEK_SET);

                    fwrite(tmp,sizeof(char),i,bfp);

                    fclose(bfp);

                    selectEntry->ind.size = selectEntry->ind.size + i;

                    selectEntry->ind.fat[1].end = selectEntry->ind.fat[1].end + i;

                    saveDir();

                    printf("文件保存成功 !\n");           }         }

          else  {

               if(i<(MAX_BLOCK_SIZE-1-selectEntry->ind.size))           {

                    FILE* bfp = fopen(blockspath,"r+");

                    if(bfp==NULL)                {

                         printf("DISK ERROR !\nFrom appendFile ...\n");

                         return;                 }

                    else                {    fseek(bfp,(selectEntry->ind.fat[0].num*(MAX_BLOCK_SIZE-1)+selectEntry->ind.size),SEEK_SET);

                         fwrite(tmp,sizeof(char),i,bfp);

                         fclose(bfp);

                         selectEntry->ind.size = selectEntry->ind.size + i;

                         selectEntry->ind.fat[0].end = selectEntry->ind.fat[0].end + i;

                         saveDir();

                         printf("文件保存成功 !\n");                }              }

               else    {

                    int bkNum = getFreeBlock(true);

                    if(bkNum==-1)                {

                         printf("数据块已用完,内存不足!\n");

                         return;                 }    char*p1=(char*)malloc((MAX_BLOCK_SIZE-1-selectEntry->ind.size)*sizeof(char)); char*p2=(char*)malloc((i-(MAX_BLOCK_SIZE-1-selectEntry->ind.size))*sizeof(char));

                    int pi;

                    int pn1=0,pn2=0;

                    for(pi=0; pi<i; pi++)                 {

                         if(pi<MAX_BLOCK_SIZE-1-selectEntry->ind.size)  {

                              p1[pn1++] = tmp[pi];                       }

                         else                     {

                              p2[pn2++] = tmp[pi];                       }}

                    p1[pn1] = '\0';

                    p2[pn2] = '\0';

                    FILE *bfp = fopen(blockspath, "r+");

                    if(bfp==NULL)                {

                         printf("DISK ERROR !\nFrom appendFile ...\n");

                         return;                 }

                    else                {    fseek(bfp,((MAX_BLOCK_SIZE-1)*selectEntry->ind.fat[0].num+selectEntry->ind.fat[0].end),SEEK_SET);

                         fwrite(p1,sizeof(char),pn1,bfp);

                         printf("line near 481\n");

                         fseek(bfp,((MAX_BLOCK_SIZE-1)*bkNum),SEEK_SET);

                         fwrite(p2,sizeof(char),pn2,bfp);

                         fclose(bfp);

                         FBT[bkNum]=1;

                         selectEntry->ind.node_num = 2;

                         selectEntry->ind.size = selectEntry->ind.size + i;

                         selectEntry->ind.fat[0].end = MAX_BLOCK_SIZE-2;

                         selectEntry->ind.fat[1].num = bkNum;

                         selectEntry->ind.fat[1].begin = 0;

                         selectEntry->ind.fat[1].end = pn2;

                         saveFBT();

                         saveDir();

                         printf("文件保存成功 !\n");}}}}}

                    void create(){

     int bkNum = getFreeBlock(false);

     if(bkNum==-1) {

          printf("数据块已用完,内存不足!\n");

          return;  }

     char tmp;

     dirEntry *pt = (dirEntry*)malloc(sizeof(dirEntry));

     pt->next=NULL;

     while(1) {

          printf("filename: ");

          scanf("%s",pt->ind.filename);

          if(isInDir(pt->ind.filename)!=NULL)       {

               printf("文件名已存在 !\n请重新输入:\n");       }

          else      {

               break;        }    }

     while(1) {

          printf("Do you want to write the file ?[y/n]: ");

          scanf(" %c",&tmp);

          if((tmp=='y')||(tmp=='Y')||(tmp=='n')||(tmp=='N'))      {

               break;        }    }

     pt->ind.num = curr_inode_num++;

     char code[10] = "wxx";

     strcpy(pt->ind.code, code);

     pt->ind.size = 0;

     pt->ind.node_num = 0;

     bool isNoBk = false;

     if(tmp=='y'||tmp=='Y') {

          char content[MAX_DATANODE_NUM][MAX_BLOCK_SIZE];

          char tmp;

          printf("End with '$'\n");

          int i = 0;

          while((tmp=getchar())!='$')      {

               if(i==0&&tmp=='\n')              {

                    continue;           }

               content[i/MAX_BLOCK_SIZE][i++] = tmp;      }

          pt->ind.size = i;

          if(i>(MAX_BLOCK_SIZE-1)*MAX_DATANODE_NUM)      {

               printf("文件过大，无法存储，创建失败 !\n");

               return;       }

          int k;

          for(k=0; k<=i/(MAX_BLOCK_SIZE-1);k++)      {

               block bk;

               int bkn;

               for(bkn=0; bkn<MAX_BLOCK_SIZE-1; bkn++)             {

                    bk.content[bkn]='$';             }

               bk.content[MAX_BLOCK_SIZE-1]='\0';

               char *tmp;

               int tp=0;

               int len=0;

               if(k==0)           {

                    if(i<MAX_BLOCK_SIZE-1)                {

                         len = i;                }              }

               if(k==1)           {

                    len=i%(MAX_BLOCK_SIZE-1)+1;           }

               for(tp=0; tp<len; tp++)           {

                    bk.content[tp] = content[k][tp];           }

               bk.isRevised = true;

               if(k==0)           {

                    bk.num = bkNum;              }

               else           {

                    bk.num = getFreeBlock(true);

                    if(bk.num==-1)                    {

                         printf("数据块已用完,内存不足!\n");

                         return;                 }              }

               saveBlock(bk);

               pt->ind.fat[k].num = bk.num;

               pt->ind.fat[k].begin = 0;

               pt->ind.fat[k].end = len;        }

          pt->ind.node_num = k;  }

     if(currEntry==NULL)    {

          DIR = pt; }

     else {

          currEntry->next = pt;  }

     currEntry = pt;

     saveDir();

     saveFBT();

     printf("Succeed create file [%s] !",pt->ind.filename);}

void del(){

     char tmp[30];

     printf("请输入要删除的文件名: ");

     scanf("%s",tmp);

     if(isInDir(tmp)==NULL) {

          printf("不存在这个文件。\n");

          return;  }

     else {

          dirEntry *dle = delHelp(tmp);

          if(dle!=NULL)      {

               int i;

               for(i=0; i<dle->ind.node_num;i++)              {

                    FBT[dle->ind.fat[i].num]=0;}}}

     saveDir();

     saveFBT();}

void open(){

     char file[50];

     printf("请输入文件名: ");

     scanf("%s",file);

     selectEntry = isInDir(file);

     if(selectEntry==NULL)  {

          printf("没有这个文件 !\n"); }

     else {

          printf("文件[%s]已打开,输入close关闭.\n",file);

          int c = 0;

          while(1)      {

               if(c==1)           {

                    break;             }

               switch(getCode())            {

                    case 5:                      read();                      break;

                    case 6:                      write();                     break;

                    case 7:                      close();                     c=1;

                    break;

                    default:

                         printf("无效的指令\n");}}}}

               void read(){

     FILE* bfp = fopen(blockspath,"r");

     if(bfp==NULL) {

          printf("不存在磁盘文件 !\n");

          while(1); }

     else {

          int i;

          char tmp = ' ';

          printf("文件[%s]中的内容如下:\n",selectEntry->ind.filename);

          if(selectEntry->ind.size==0)          {

               printf("内容为空。\n");      }

          else      {

               for(i=0; i<selectEntry->ind.node_num; i++)               {     fseek(bfp,(selectEntry->ind.fat[i].num*(MAX_BLOCK_SIZE-1)),SEEK_SET);       

                    int j;

                    for(j=selectEntry->ind.fat[i].begin;j<selectEntry->ind.fat[i].end;j++)     {

                         tmp = fgetc(bfp);

                         printf("%c",tmp);                 }              }

               printf("\n");      }

          fclose(bfp);  }}

void close(){

     selectEntry==NULL;

     printf("文件已关闭 !\n");}

void write(){

     char sel[10];

     char cm_cover[10] = "cover";

     char cm_append[10] = "append";

     while(1) {

          printf("请输入指令:\n[append]:在原文件基础上新增数据.\n[cover]:覆盖原数据\n[cancle]:取消\n");

          printf("Command: ");

          scanf("%s",sel);

          if(!strcmpi(sel,cm_cancle))      {

               printf("取消 !\n");

               break;        }

          if(!strcmpi(sel,cm_cover))       {

               coverHelp();

               break;        }

          if(!strcmpi(sel,cm_append))      {

               if(selectEntry->ind.size==0)               {

                    coverHelp();            }

               else           {

                    appendHelp();           }

               break;        }

          printf("指令无效\n");  }}

void initFBT(){

     FILE* fp;

     fp = fopen(fbtpath, "r");

     if(fp==NULL)  {

          printf("Can not open FBT files.\n");

          while(1); }

     else {

          int i=0;

          while(!feof(fp))        {

               fscanf(fp,"%d",&FBT[i++]);

               if(i==MAX_BLOCK_SIZE-1)           {

                    break;}}}}

int getCode(){

     char cmd[10];

     printf("Command: ");

     scanf("%s",cmd);

     if(!strcmpi(cmd, cm_exit))  {

          return -1;    }

     if(!strcmpi(cmd, cm_help))  {

          return 0; }

     if(!strcmpi(cmd, cm_dir))   {

          return 1; }

     if(!strcmpi(cmd, cm_create))     {

          return 2; }

     if(!strcmpi(cmd, cm_delete))     {

          return 3; }

     if(!strcmpi(cmd, cm_open))  {

          return 4; }

     if(!strcmpi(cmd, cm_read))  {

          return 5; }

     if(!strcmpi(cmd, cm_write)) {

          return 6; }

     if(!strcmpi(cmd, cm_close)) {

          return 7; }

     return 8;}

int getAction(){

     switch(getCode())  {

          case -1:           {

                    return -1;              }

          case 0:            help();            break;

          case 1:            dir();             break;

          case 2:            create();           break;

          case 3:            del();             break;

          case 4:            open();            break;

          default:

               printf("无效的指令\n"); }

     return 0;}

FILE* createDir(char *dirpath){

     FILE *fp = fopen(dirpath, "w");

     if(fp==NULL)  {

          printf("Can not create Directory !\n");

          while(1); }

     else {

          fclose(fp);

          FILE *f = fopen(dirpath, "r");

          return f; }}

char *getDirpath(char* username){

     char *res;

     res = (char*)malloc(50*sizeof(char));

     char t[10] = "userdata/";

     char tail[5] = ".dir";

     strcpy(res, t);

     strcat(res, username);

     strcat(res, tail);

     return res;}

void initDir(char *dirpath){

     FILE *p ;

     p = fopen(dirpath, "r");

     if(p==NULL)   {

          p = createDir(dirpath); }

     dirEntry* pp = (dirEntry*)malloc(sizeof(dirEntry));

     pp->next=NULL;

     DIR = NULL;

     int nm = 0;

     while(!feof(p))    {

          if(nm!=0)      {

               dirEntry* pt = (dirEntry*)malloc(sizeof(dirEntry));

               pt->next=NULL;    

               pp->next = pt;

               pp=pt;        }

          int r = fscanf(p,"%s",pp->ind.filename);

          if(r==EOF)         {

               break;        }

          fscanf(p,"%d",&(pp->ind.num));

          if(max_node < pp->ind.num)       {

               max_node = pp->ind.num;      }

          fscanf(p,"%s",pp->ind.code);

          fscanf(p,"%d",&pp->ind.size);

          if(pp->ind.size!=0)         {

               fscanf(p,"%d",&pp->ind.node_num);

               int j;

               int temp = 0;

               for(j=0;j<pp->ind.node_num; j++)           {

                    fscanf(p,"%d",&pp->ind.fat[j].num);

                    fscanf(p,"%d",&pp->ind.fat[j].begin);

                    fscanf(p,"%d",&pp->ind.fat[j].end);            }         }

          curr_inode_num++;

          if(curr_inode_num == MAX_INODE_NUM)       {

               break;        }

          if(nm==0)      {

               DIR=pp;

               nm = 1;       }

          currEntry = pp;    }

     fclose(p);}

void init()    {

     initDir(getDirpath(currUser.account));

     printf("");

     initFBT();

     printf("");}

void start(){

     printf("欢迎使用虚拟文件管理系统 \n");

     FILE *ufp = fopen(userspath, "r");       

     if(ufp==NULL) {

          printf("\n");

          createDataDir();

          FILE *fp = fopen(userspath,"w");

          createBlocksDisk();                        

          if(fp==NULL)       {

               printf("\n严重错误！\n");

               while(1);

               return;      }

          else      {

               fclose(fp);        }    }

     else {

          fclose(ufp);  }

     while(LgRg());

     printf("已进入文件管理虚拟系统\n");

     dirpath = getDirpath(currUser.account);

     init();

     printf("输入help查看命令帮助,输入exit/quit退出系统\n");

     while(getAction()!=-1);}

void getUser(){

     while(1) {

          printf("account(length<10): ");

          scanf("%s", currUser.account);

          if(strlen(currUser.account)<=10)      {

               break;        }

          else      {

               printf("账户名最长为10位.\n");       }    }

     while(1) {

          printf("password(length<10): ");

          scanf("%s", currUser.password);

          if(strlen(currUser.password)<=10)         {

               break;        }

          else      {

               printf("账户名最长为10位.\n");}}}       

int login(){

     getUser();

     FILE *ffp = fopen(userspath, "r");

     if(ffp==NULL) {

          printf("FILE ERROR !");

          exit(0); }

     else {

          user temp;

          while(!feof(ffp))       {

               fscanf(ffp,"%s",temp.account);

               fscanf(ffp,"%s",temp.password);

               if((!strcmpi(temp.account, currUser.account))&&(!strcmpi(temp.password, currUser.password)))           {

                    fclose(ffp);

                    return 0;           }         }

          fclose(ffp);

          return -1;    }}

int regist(){

     getUser();

     FILE *fp = fopen(userspath, "a");

     if(fp==NULL)  {

          printf("FILE ERROR !");

          return -1;    }

     else {

          fprintf(fp,"%s ",currUser.account);

          fprintf(fp," %s\n",currUser.password);

          fclose(fp);

          return 0; }}

int LgRg(){

     char com[10];

     char type = lgOrRg();

     if(type=='l') {

          if(login())        {

               printf("登录失败 ！\n");

               return -1;              }

          else      {

               printf("登录成功 ！\n");

               return 0;      }}

     else {

          if(regist())       {

               printf("注册失败 ！\n");

               return -1;         }

          else      {

               printf("注册成功 ！\n");

               return 0;     }}}

void dir(){

     printf("文件名\t物理地址\t保护码\t\t文件长度\n");

     int i=0;

     dirEntry *pt = DIR;

     while(pt!=NULL)    {

          printf("%s\t%d\t\t%s\t\t%d\n",pt->ind.filename,i++,pt->ind.code,pt->ind.size);

          pt=pt->next;  }}

void saveDir(){

     //printf("dirpath = %s\n",dirpath);

     FILE *fp = fopen(getDirpath(currUser.account), "w");

     if(fp==NULL)  {

          printf("updateDirDisk ERROR !\n");

          while(1); }

     else {

          int j;

          dirEntry *p = DIR;

          while(p!=NULL)          {

               fprintf(fp," %s",p->ind.filename);

               fprintf(fp," %d",p->ind.num);

               fprintf(fp," %s",p->ind.code);

               fprintf(fp," %d",p->ind.size);

               if(p->ind.size!=0)           {

                    fprintf(fp," %d",p->ind.node_num);

                    for(j=0; j<p->ind.node_num; j++)                {

                         fprintf(fp," %d",p->ind.fat[j].num);

                         fprintf(fp," %d",p->ind.fat[j].begin);

                         fprintf(fp," %d",p->ind.fat[j].end);                }              }

               p=p->next;         }

          fclose(fp);   }}

void saveBlock(block bk){

     FILE *fp = fopen(blockspath, "r+");

     if(fp==NULL)  {

          printf("SaveBlock ERROR !\n");   }

     else {

          long offset = bk.num * (MAX_BLOCK_SIZE-1);

          fseek(fp,offset,SEEK_SET);

          fwrite(bk.content,sizeof(char),strlen(bk.content),fp);

          fclose(fp);

          FBT[bk.num] = 1;   }}

void saveFBT(){

     FILE* fp = fopen(fbtpath, "w");

     if(fp==NULL)  {

          printf("SaveFBT ERROR !\n");

          while(1); }

     else {

          int i;

          for(i =0; i<MAX_BLOCKS_NUM; i++)      {

               fprintf(fp," %d",FBT[i]);        }

          fclose(fp);   }}

int getFreeBlock(bool isAdd)  {                             

     int pos = -1;

     int num = 0;

     int k;

     for(k=0; k<MAX_BLOCKS_NUM; k++)  {

          if(FBT[k]==0)      {

               if(isAdd == true)            {

                    return k;           }

               if(num==0)              {

                    pos = k;

                    num++;             }

               else           {

                    return pos;}}}}

     return -1;}

void main(){

     start();   }