00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #include "fs/fat12.h"
00019 #include "core/kasm.h"
00020 #include "mm/mm.h"
00021
00022 volatile fs_request fsreqs[MAX_FS_REQ];
00023 int fs_en_req = 0;
00024 int fs_fr_req = 0;
00025 volatile int no_fs_req = 0;
00026 struct dir_des dd[MAX_PROC][MAX_DIR];
00027 struct file_des fd[MAX_PROC][MAX_FILE];
00028
00029 int form_time()
00030 {
00031 int hh,mm,ss,tm;
00032 TIME t = {0,0,0};
00033 gettime(&t);
00034 hh = t.hour;
00035 mm = t.min;
00036 ss = t.sec/2;
00037 printf("%d %d %d\n",hh,mm,ss);
00038 tm = (hh << 11) | (mm << 5) | ss;
00039 printf("tm %x\n",tm);
00040 return tm;
00041 }
00042 void get_time(int ti,TIME *t)
00043 {
00044 t->hour = (ti >> 11) & 0x1F;
00045 t->min = (ti >> 5) & 0x3F;
00046 t->sec = ti & 0x1F;
00047 }
00048 int form_date()
00049 {
00050 int dd,mm,yy,dt;
00051 DATE d = {0,0,0};
00052 getdate(&d);
00053 yy = d.yy;
00054 mm = d.mm;
00055 dd = d.dd;
00056 dt = ((yy-1980) <<9) | (mm << 5) | dd;
00057 printf("dt %x\n",dt);
00058 return dt;
00059 }
00060 void get_date(int dt,DATE *d)
00061 {
00062 d->dd = dt & 0x1F;
00063 d->mm = (dt >> 5) & 0xF;
00064 d->yy = (dt >> 9) & 0x7F;
00065 d->yy = d->yy + 1980;
00066 }
00067 unsigned char ChkSum (unsigned char *name)
00068 {
00069 short len;
00070 unsigned char sum;
00071 sum = 0;
00072 for (len=11; len!=0; len--)
00073 {
00074 sum = ((sum & 1) ? 0x80 : 0) + (sum >> 1) + *name++;
00075 }
00076 return (sum);
00077 }
00078 void parse_fat(int * fat_entry,int fat1,int fat2,int in)
00079 {
00080 int fat;
00081 if(in%2 == 0)
00082 fat = ((fat2 & 0x0f) << 8) | fat1;
00083 else
00084 fat = (fat2 << 4) | ((fat1 &0x0f0) >> 4);
00085
00086 fat = fat & 0xFFF;
00087 *fat_entry = fat;
00088
00089
00090 printf("\nfat1 = %d %x fat2 %d %x",fat1,fat1,fat2,fat2);
00091 printf("\nfat: %d %x\n",fat,fat);
00092
00093 }
00094
00095 int read_fat(int *fat_entry,int in,int st_sec)
00096 {
00097 int fat_in,fat,res;
00098 unsigned char a[512];
00099 int fat1,fat2,fat_ent;
00100 fat_in = (in*3)/2;
00101 st_sec = st_sec + fat_in/512;
00102 if(fat_in % 512 == 511)
00103 {
00104
00105 res = read_sector(st_sec,a);
00106 if(res != 0)
00107 return E_DISK;
00108 fat1 = a[511];
00109 res = read_sector(st_sec+1,a);
00110 fat2 = a[0];
00111 }
00112 else
00113 {
00114 fat_in = fat_in%512;
00115 res = read_sector(st_sec,a);
00116 if(res != 0)
00117 return E_DISK;
00118 fat1 = a[fat_in] & 0xff;
00119 fat2 = a[fat_in+1] & 0xff;
00120 }
00121 parse_fat(fat_entry,fat1,fat2,in);
00122
00123
00124 return 0;
00125 }
00126 int write_fat(int fat,int in,int st_sec)
00127 {
00128 int fat_in,res;
00129 unsigned char a[512],b[512];
00130 char fat1,fat2;
00131
00132
00133
00134
00135 fat_in = (in*3)/2;
00136
00137
00138
00139 st_sec = st_sec + fat_in/512;
00140 fat_in = fat_in%512;
00141
00142 printf("writting fat %d to sec %d in %d sector_in %d",fat,st_sec,fat_in,in + DATA_SEC -2);
00143
00144 if(fat_in == 511)
00145 {
00146
00147 res = read_sector(st_sec,a);
00148 if(res != 0)
00149 return E_DISK;
00150 fat1 = a[511];
00151 res = read_sector(st_sec+1,b);
00152 if(res != 0)
00153 return E_DISK;
00154 fat2 = b[0];
00155 }
00156 else
00157 {
00158 res = read_sector(st_sec,a);
00159 if(res != 0)
00160 return E_DISK;
00161 fat1 = a[fat_in];
00162 fat2 = a[fat_in+1];
00163 }
00164
00165
00166
00167 if(in%2 == 0)
00168 {
00169 fat1 = fat &0x0ff;
00170 fat2 = (fat2 & 0xf0) | ((fat & 0xf00) >> 8);
00171 }
00172 else
00173 {
00174 fat1 = (fat1 &0x0f) | ( (fat & 0x00f) << 4);
00175 fat2 = (fat & 0xff0) >>4;
00176 }
00177
00178
00179
00180 if(fat_in == 511)
00181 {
00182 a[511]=fat1;
00183 b[0] = fat2;
00184 res = write_sector(st_sec,a);
00185 if(res != 0)
00186 return E_DISK;
00187 res = write_sector(st_sec+1,b);
00188 if(res != 0)
00189 return E_DISK;
00190 }
00191 else
00192 {
00193 a[fat_in] = fat1;
00194 a[fat_in+1] = fat2;
00195 res = write_sector(st_sec,a);
00196 if(res != 0)
00197 return E_DISK;
00198 }
00199 return 0;
00200 }
00201 int write_dir(struct dir_entry *rs,int in,int st_sec)
00202 {
00203 unsigned char a[512];
00204 int i,j;
00205 st_sec = st_sec + in/DIR_ENTRIES;
00206
00207 if(read_sector(st_sec,a) != 0)
00208 return E_DISK;
00209 printf("writting dir to sec %d in %d\n",st_sec,in);
00210 i = (in % DIR_ENTRIES) *32;
00211
00212 for(j=0;j<8;j++,i++)
00213 a[i] = rs->Filename[j];
00214
00215 for(j=0;j<3;j++,i++)
00216 a[i] = rs->Extension[j];
00217
00218 a[i++] = rs->Attributes;
00219 a[i++] = rs->NTRes;
00220 a[i++] = rs->CrtTimeTenth;
00221
00222 a[i] = BYTE1(rs->CrtTime);
00223
00224 a[i+1] = BYTE2(rs->CrtTime);
00225 i+= 2;
00226
00227 a[i] = BYTE1(rs->CrtDate);
00228 a[i+1] = BYTE2(rs->CrtDate);
00229 i+= 2;
00230
00231 a[i] = BYTE1(rs->LstAccDate);
00232 a[i+1] = BYTE2(rs->LstAccDate);
00233 i+=2;
00234
00235 a[i] = BYTE1(rs->FstClusHI);
00236 a[i+1] = BYTE2(rs->FstClusHI);
00237 i+=2;
00238
00239 a[i] = BYTE1(rs->WrtTime);
00240 a[i+1] = BYTE2(rs->WrtTime);
00241 i+=2;
00242
00243 a[i] = BYTE1(rs->WrtDate);
00244 a[i+1] = BYTE2(rs->WrtDate);
00245 i+=2;
00246
00247 a[i] = BYTE1(rs->FstClusLO);
00248 a[i+1] = BYTE2(rs->FstClusLO);
00249 i+=2;
00250
00251 a[i] = BYTE1(rs->FileSize);
00252 a[i+1] = BYTE2(rs->FileSize);
00253 a[i+2] = BYTE3(rs->FileSize);
00254 a[i+3] = BYTE4(rs->FileSize);
00255 i+=4;
00256
00257 return write_sector(st_sec,a);
00258 }
00259 void print_dir(struct dir_entry *rs)
00260 {
00261 int j;
00262 printf("File Name : ");
00263 for(j=0;j<8;j++)
00264 printf("%c",rs->Filename[j]);
00265 printf("\n");
00266
00267 printf("Extension : ");
00268 for(j=0;j<3;j++)
00269 printf("%c",rs->Extension[j]);
00270 printf("\n");
00271
00272 printf("Attributes = %c %d %x\n",rs->Attributes,rs->Attributes,rs->Attributes);
00273 printf("NTRes = %c %d %x\n",rs->NTRes,rs->NTRes,rs->NTRes);
00274 printf("CrtTimeTenth = %c %d %x\n",rs->CrtTimeTenth,rs->CrtTimeTenth,rs->CrtTimeTenth);
00275 printf("CrtTime = %c %d %x\n",rs->CrtTime,rs->CrtTime,rs->CrtTime);
00276 printf("CrtDate = %c %d %x\n",rs->CrtDate,rs->CrtDate,rs->CrtDate);
00277 printf("LstAccDate = %c %d %x\n",rs->LstAccDate,rs->LstAccDate,rs->LstAccDate);
00278 printf("FstClusHI = %c %d %x\n",rs->FstClusHI,rs->FstClusHI,rs->FstClusHI);
00279 printf("WrtTime = %c %d %x\n",rs->WrtTime,rs->WrtTime,rs->WrtTime);
00280 printf("WrtDate = %c %d %x\n",rs->WrtDate,rs->WrtDate,rs->WrtDate);
00281 printf("FstClusLO = %c %d %x\n",rs->FstClusLO,rs->FstClusLO,rs->FstClusLO);
00282 printf("FileSize = %c %d %x\n",rs->FileSize,rs->FileSize,rs->FileSize);
00283
00284 }
00285 void parse_dir(unsigned char *a,int in,struct dir_entry *rs)
00286 {
00287 int i,j;
00288
00289 i = (in %DIR_ENTRIES) * 32;
00290
00291 for(j=0;j<8;j++,i++)
00292 rs->Filename[j] = a[i];
00293
00294 for(j=0;j<3;j++,i++)
00295 rs->Extension[j] = a[i];
00296
00297 rs->Attributes = a[i++];
00298 rs->NTRes = a[i++];
00299 rs->CrtTimeTenth = a[i++];
00300
00301 rs->CrtTime = FORM_INT(a[i],a[i+1]);
00302 i+= 2;
00303
00304 rs->CrtDate = FORM_INT(a[i],a[i+1]);
00305 i+= 2;
00306
00307 rs->LstAccDate = FORM_INT(a[i],a[i+1]);
00308 i+=2;
00309
00310 rs->FstClusHI = FORM_INT(a[i],a[i+1]);
00311 i+=2;
00312
00313 rs->WrtTime = FORM_INT(a[i],a[i+1]);
00314 i+=2;
00315
00316 rs->WrtDate = FORM_INT(a[i],a[i+1]);
00317 i+=2;
00318
00319 rs->FstClusLO = FORM_INT(a[i],a[i+1]);
00320 i+=2;
00321
00322 rs->FileSize = FORM_LONG(a[i],a[i+1],a[i+2],a[i+3]);
00323 i+=4;
00324 }
00325
00326 int read_dir(struct dir_entry *rs,int in,int st_sec)
00327 {
00328 unsigned char a[512];
00329 int i,j;
00330 st_sec = st_sec + in/DIR_ENTRIES;
00331 if(read_sector(st_sec,a) != 0)
00332 return E_DISK;
00333 parse_dir(a,in,rs);
00334
00335 #ifdef DEBUG
00336 print_dir(rs);
00337 #endif
00338 return 0;
00339 }
00340 int write_long_dir(struct long_dir_entry *rs,int in,int st_sec)
00341 {
00342 unsigned char a[512];
00343 int i,j;
00344 if(read_sector(st_sec,a) != 0)
00345 return E_DISK;
00346 i = in * 32;
00347
00348 a[i++] = rs->LDIR_Ord;
00349
00350 for(j=0;j<10;j++,i++)
00351 a[i] = rs->LDIR_Name1[j];
00352
00353 a[i++] = rs->LDIR_Attr;
00354 a[i++] = rs->LDIR_Type;
00355 a[i++] = rs->LDIR_Chksum;
00356
00357 for(j=0;j<12;j++,i++)
00358 a[i] = rs->LDIR_Name2[j];
00359
00360 a[i] = BYTE1(rs->LDIR_FstClusLO);
00361 a[i+1] = BYTE2(rs->LDIR_FstClusLO);
00362 i+= 2;
00363
00364 for(j=0;j<4;j++,i++)
00365 a[i] = rs->LDIR_Name3[j];
00366
00367 return write_sector(st_sec,a);
00368 }
00369 void parse_long_dir(struct long_dir_entry *rs,unsigned char *a,int i)
00370 {
00371 int j;
00372 i = i*32;
00373
00374 rs->LDIR_Ord = a[i++];
00375
00376 for(j=0;j<10;j++,i++)
00377 rs->LDIR_Name1[j] = a[i];
00378
00379 rs->LDIR_Attr = a[i++];
00380 rs->LDIR_Type = a[i++];
00381 rs->LDIR_Chksum = a[i++];
00382
00383 for(j=0;j<12;j++,i++)
00384 rs->LDIR_Name2[j] = a[i];
00385
00386 rs->LDIR_FstClusLO = FORM_INT(a[i],a[i+1]);
00387 i+= 2;
00388
00389 for(j=0;j<4;j++,i++)
00390 rs->LDIR_Name3[j] = a[i] ;
00391 }
00392 void print_long_dir(struct long_dir_entry *rs)
00393 {
00394 int i,j;
00395 printf("Long Name : ");
00396 for(j=0;j<10;j++,i++)
00397 printf("%c",rs->LDIR_Name1[j]);
00398 printf(" ");
00399 for(j=0;j<12;j++,i++)
00400 printf("%c",rs->LDIR_Name2[j]);
00401 printf(" ");
00402 for(j=0;j<4;j++,i++)
00403 printf("%c",rs->LDIR_Name3[j]);
00404 printf("\n");
00405
00406 printf("LDIR_Attr : %d %x\n",rs->LDIR_Attr,rs->LDIR_Attr);
00407 printf("LDIR_Ord : %d %x\n",rs->LDIR_Ord,rs->LDIR_Ord);
00408 printf("LDIR_Type :%d %x\n",rs->LDIR_Type,rs->LDIR_Type);
00409 printf("LDIR_Chksum : %d %x\n",rs->LDIR_Chksum,rs->LDIR_Chksum);
00410 printf("LDIR_FstClusLO : %d %x\n",rs->LDIR_FstClusLO,rs->LDIR_FstClusLO);
00411 }
00412 int read_long_dir(struct long_dir_entry *rs,int in,int st_sec)
00413 {
00414 unsigned char a[512];
00415 int i,j;
00416 st_sec = st_sec + in/DIR_ENTRIES;
00417 if(read_sector(st_sec,a) != 0)
00418 return E_DISK;
00419 i = (in %DIR_ENTRIES) * 32;
00420 if(a[i+11] == ATTR_LONG_NAME)
00421 {
00422 parse_long_dir(rs,a,i);
00423
00424 #ifdef DEBUG
00425 print_long_dir(rs);
00426 #endif
00427 }
00428 else
00429 return E_NOT_LONG;
00430 }
00431 void print_boot_sector(struct boot_sector *bs)
00432 {
00433 printf("jumpBoot= %s\n",bs->jumpBoot);
00434 printf("SysName = %s\n",bs->SysName);
00435 printf("charsPerSector = %d\n",bs->charsPerSector);
00436 printf("SectorsPerCluster = %d\n",bs->SectorsPerCluster);
00437 printf("ReservedSectors = %d\n",bs->ReservedSectors);
00438 printf("FATcount = %d\n",bs->FATcount);
00439 printf("MaxRootEntries = %d\n",bs->MaxRootEntries);
00440 printf("TotalSectors1 = %d\n",bs->TotalSectors1);
00441 printf("MediaDescriptor = %d\n",bs->MediaDescriptor);
00442 printf("SectorsPerFAT = %d\n",bs->SectorsPerFAT);
00443 printf("SectorsPerTrack = %d\n",bs->SectorsPerTrack);
00444 printf("HeadCount = %d\n",bs->HeadCount);
00445 printf("HiddenSectors = %d\n",bs->HiddenSectors);
00446 printf("TotalSectors2 = %d\n",bs->TotalSectors2);
00447 printf("DriveNumber = %d\n",bs->DriveNumber);
00448 printf("Reserved1 = %d\n",bs->Reserved1);
00449 printf("ExtBootSignature = %d\n",bs->ExtBootSignature);
00450 printf("VolumeSerial = %d\n",bs->VolumeSerial);
00451 printf("VolumeLabel = %s\n",bs->VolumeLabel);
00452 printf("Reserved2 = %s\n",bs->VolumeLabel);
00453 }
00454
00455 int read_boot_sector(struct boot_sector *bs)
00456 {
00457 int i,j;
00458
00459 unsigned char a[512];
00460
00461 if(read_sector(0,a) != 0)
00462 return E_DISK;
00463
00464 i=0;
00465 for(j=0;j<3;j++)
00466 bs->jumpBoot[j]=a[j];
00467
00468 i+= 3;
00469 for(j=0;j<8;j++,i++)
00470 bs->SysName[j] = a[i];
00471
00472 bs->charsPerSector = FORM_INT(a[i],a[i+1]);
00473 i+=2;
00474
00475 bs->SectorsPerCluster = a[i++];
00476
00477 bs->ReservedSectors = FORM_INT(a[i],a[i+1]);
00478 i+=2;
00479
00480 bs->FATcount = a[i++];
00481
00482 bs->MaxRootEntries = FORM_INT(a[i],a[i+1]);
00483 i+=2;
00484
00485 bs->TotalSectors1 = FORM_INT(a[i],a[i+1]);
00486 i+=2;
00487
00488 bs->MediaDescriptor = a[i++];
00489
00490 bs->SectorsPerFAT = FORM_INT(a[i],a[i+1]);
00491 i+=2;
00492
00493 bs->SectorsPerTrack = FORM_INT(a[i],a[i+1]);
00494 i+=2;
00495
00496 bs->HeadCount = FORM_INT(a[i],a[i+1]);
00497 i+=2;
00498
00499 bs->HiddenSectors = FORM_LONG(a[i],a[i+1],a[i+2],a[i+3]);
00500 i+=4;
00501
00502
00503 bs->TotalSectors2 = FORM_LONG(a[i],a[i+1],a[i+2],a[i+3]);
00504 i+=4;
00505
00506 bs->DriveNumber = a[i++];
00507 bs->Reserved1 = a[i++];
00508 bs->ExtBootSignature = a[i++];
00509 bs->VolumeSerial = FORM_LONG(a[i],a[i+1],a[i+2],a[i+3]);
00510 i+=4;
00511
00512
00513
00514 for(j=0;j<11;j++,i++)
00515 bs->VolumeLabel[j] = a[i];
00516 for(j=0;j<8;j++,i++)
00517 bs->Reserved2[j] = a[i];
00518
00519 #ifdef DEBUG
00520 print_boot_sector(bs);
00521 #endif
00522 return 0;
00523 }
00524 int write_boot_sector(struct boot_sector *bs)
00525 {
00526 int i,j;
00527 unsigned char a[512];
00528
00529 i=0;
00530 for(j=0;j<3;j++)
00531 a[j]=bs->jumpBoot[j];
00532
00533 i+= 3;
00534 for(j=0;j<8;j++,i++)
00535 a[i]= bs->SysName[j];
00536
00537 a[i] = BYTE1(bs->charsPerSector);
00538 a[i+1] =BYTE2(bs->charsPerSector);
00539 i+=2;
00540
00541
00542 a[i++] = bs->SectorsPerCluster;
00543
00544
00545 a[i] = BYTE1(bs->ReservedSectors);
00546 a[i+1] =BYTE2(bs->ReservedSectors);
00547 i+=2;
00548
00549 a[i++] = bs->FATcount;
00550
00551 a[i] = BYTE1(bs->MaxRootEntries);
00552 a[i+1] =BYTE2(bs->MaxRootEntries);
00553 i+=2;
00554
00555 a[i] = BYTE1(bs->TotalSectors1);
00556 a[i+1] =BYTE2(bs->TotalSectors1);
00557 i+=2;
00558
00559 a[i++] = bs->MediaDescriptor;
00560
00561 a[i] = BYTE1(bs->SectorsPerFAT);
00562 a[i+1] =BYTE2(bs->SectorsPerFAT);
00563 i+=2;
00564
00565 a[i] = BYTE1(bs->SectorsPerTrack);
00566 a[i+1] =BYTE2(bs->SectorsPerTrack);
00567 i+=2;
00568
00569
00570 a[i] = BYTE1(bs->HeadCount);
00571 a[i+1] =BYTE2(bs->HeadCount);
00572 i+=2;
00573
00574 a[i] = BYTE1(bs->HiddenSectors);
00575 a[i+1] =BYTE2(bs->HiddenSectors);
00576 a[i+2] = BYTE3(bs->HiddenSectors);
00577 a[i+3] =BYTE4(bs->HiddenSectors);
00578 i+=4;
00579
00580 a[i] = BYTE1(bs->TotalSectors2);
00581 a[i+1] =BYTE2(bs->TotalSectors2);
00582 a[i+2] = BYTE3(bs->TotalSectors2);
00583 a[i+3] =BYTE4(bs->TotalSectors2);
00584 i+=4;
00585
00586 a[i++] = bs->DriveNumber;
00587 a[i++] = bs->Reserved1;
00588 a[i++] = bs->ExtBootSignature;
00589
00590 a[i] = BYTE1(bs->VolumeSerial);
00591
00592 a[i+1] =BYTE2(bs->VolumeSerial);
00593 a[i+2] = BYTE3(bs->VolumeSerial);
00594 a[i+3] =BYTE4(bs->VolumeSerial);
00595 i+=4;
00596
00597 for(j=0;j<11;j++,i++)
00598 a[i] = bs->VolumeLabel[j];
00599
00600 for(j=0;j<8;j++,i++)
00601 a[i] = bs->Reserved2[j];
00602
00603 return write_sector(0,a);
00604
00605 }
00606 int read_sector(int offs,unsigned char *a)
00607 {
00608 int i,j,tmp;
00609 if(offs < 0 || offs > MAX_SECTOR)
00610 return E_DISK;
00611
00612 __asm__ __volatile__("pushl %%eax"::"a"(a));
00613 __asm__ __volatile__("pushl %%eax"::"a"(offs));
00614 __asm__ __volatile__("int $0x30"::"a"(8));
00615
00616 asm("pushl %eax");
00617 asm("popl %0"::"r"(tmp));
00618 if(tmp != 0)
00619 {
00620 __asm__ __volatile__("pushl %%eax"::"a"(a));
00621 __asm__ __volatile__("pushl %%eax"::"a"(offs));
00622 __asm__ __volatile__("int $0x30"::"a"(8));
00623
00624 asm("pushl %eax");
00625 asm("popl %0"::"r"(tmp));
00626 if(tmp != 0)
00627 return -1;
00628 }
00629
00630
00631 #ifdef DEBUG
00632 printf("read:\n");
00633 for(i=0;i<512;i++)
00634 printf("%d %d %x %c\n",i,a[i],a[i],a[i]);
00635 printf("\n");
00636 #endif
00637 return 0;
00638 }
00639 int write_sector(int offs,unsigned char *a)
00640 {
00641 int i,j,tmp;
00642
00643 if(offs < 0 || offs > MAX_SECTOR)
00644 return E_DISK;
00645
00646 __asm__ __volatile__("pushl %%eax"::"a"(a));
00647 __asm__ __volatile__("pushl %%eax"::"a"(offs));
00648 __asm__ __volatile__("int $0x30"::"a"(9));
00649
00650 asm("pushl %eax");
00651 asm("popl %0"::"r"(tmp));
00652 if(tmp != 0)
00653 {
00654 __asm__ __volatile__("pushl %%eax"::"a"(a));
00655 __asm__ __volatile__("pushl %%eax"::"a"(offs));
00656 __asm__ __volatile__("int $0x30"::"a"(9));
00657
00658 asm("pushl %eax");
00659 asm("popl %0"::"r"(tmp));
00660
00661 if(tmp != 0)
00662 return -1;
00663 }
00664
00665
00666 return 0;
00667 }
00668 int clear_sec(int sec)
00669 {
00670
00671 int i,j;
00672 unsigned char a[512];
00673
00674 if(sec < 0 || sec > MAX_SECTOR)
00675 return E_DISK;
00676 for(i=0;i<512;i++)
00677 a[i] = 0;
00678 write_sector(sec,a);
00679
00680 return 0;
00681
00682 }
00683 void print_DIRENT(DIRENT *ds)
00684 {
00685 int j;
00686 printf("File Name : %s",ds->name);
00687
00688 printf("Attributes = %c %d %x\n",ds->attribute,ds->attribute,ds->attribute);
00689 printf("CrtDt d %d m %d y %d\n",ds->crt_dt.dd,ds->crt_dt.mm,ds->crt_dt.yy);
00690 printf("CRttime h %d min %d sec %d\n",ds->crt_time.hour,ds->crt_time.min,ds->crt_time.sec);
00691 printf("AccDt d %d m %d y %d\n",ds->acc_dt.dd,ds->acc_dt.mm,ds->acc_dt.yy);
00692 printf("WrtDt d %d m %d y %d\n",ds->mod_dt.dd,ds->mod_dt.mm,ds->mod_dt.yy);
00693 printf("Wrttime h %d min %d sec %d\n",ds->mod_time.hour,ds->mod_time.min,ds->mod_time.sec);
00694 printf("Clus = %d \n",ds->clu);
00695 printf("FileSize = %d \n",ds->size);
00696 }
00697
00698 int format(char *vlab)
00699 {
00700 int res;
00701 struct boot_sector b;
00702 struct dir_entry d;
00703 unsigned char a[512];
00704 int i,j,dt,tm;
00705
00706 for(i=0;i<11;i++)
00707 if(vlab[i] == '\0')
00708 break;
00709 for(j=i;j<11;j++)
00710 vlab[j] = ' ';
00711 b.jumpBoot[0] = 0xeb;
00712 b.jumpBoot[1] = 0x3c;
00713 b.jumpBoot[2] = 0x90;
00714 b.SysName[0] = 'D';
00715 b.SysName[1] = 'Y';
00716 b.SysName[2] = 'N';
00717 b.SysName[3] = 'A';
00718 b.SysName[4] = 'C';
00719 b.SysName[5] = 'U';
00720 b.SysName[6] = 'B';
00721 b.SysName[7] = 'E';
00722 b.charsPerSector= 512;
00723 b.SectorsPerCluster = 1;
00724 b.ReservedSectors = 1;
00725 b.FATcount = 2;
00726 b.MaxRootEntries = 224;
00727 b.TotalSectors1 = 2880;
00728 b.MediaDescriptor = 0xF0;
00729 b.SectorsPerFAT = 9;
00730 b.SectorsPerTrack = 18;
00731 b.HeadCount = 2;
00732 b.HiddenSectors = 0;
00733 b.TotalSectors2 = 0;
00734 b.DriveNumber = 0;
00735 b.Reserved1 = 0;
00736 b.ExtBootSignature = 0x29;
00737 dt = form_date();
00738 tm = form_time();
00739 dt = ((dt & 0xff) << 8) | ((dt & 0xff00) >> 8);
00740 tm = ((tm & 0xff) << 8) | ((tm & 0xff00) >> 8);
00741 b.VolumeSerial = tm << 16 + dt;
00742 for(i=0;i<11;i++)
00743 b.VolumeLabel[i] = vlab[i];
00744 b.Reserved2[0] = 'F';
00745 b.Reserved2[1] = 'A';
00746 b.Reserved2[2] = 'T';
00747 b.Reserved2[3] = '1';
00748 b.Reserved2[4] = '2';
00749 b.Reserved2[5] = ' ';
00750 b.Reserved2[6] = ' ';
00751 b.Reserved2[7] = ' ';
00752 res = write_boot_sector(&b);
00753 if(res != 0)
00754 return E_DISK;
00755
00756 for(i=0;i<512;i++)
00757 a[i] = 0;
00758 printf(" 03 %% Format Completed\r");
00759 for(i=1;i<33;i++)
00760 {
00761 res = write_sector(i,a);
00762 if(res != 0)
00763 return E_DISK;
00764
00765 printf(" %d %%\r",(int)i*100/38);
00766 }
00767
00768
00769
00770 a[0] = 0xf0;
00771 a[1] = 0xff;
00772 a[2] = 0xff;
00773 for(i=3;i<512;i++)
00774 a[i] = 0;
00775 write_sector(FAT1_SEC,a);
00776 write_sector(FAT2_SEC,a);
00777
00778 a[0] = 0; a[1] =0; a[2] =0;
00779 for(i=FAT1_SEC+1;i<FAT2_SEC;i++)
00780 {
00781 res = write_sector(i,a);
00782 if(res != 0)
00783 return E_DISK;
00784 res = write_sector(i+9,a);
00785 if(res != 0)
00786 return E_DISK;
00787 }
00788
00789 for(i=0;i<8;i++)
00790 d.Filename[i] = vlab[i];
00791 for(i=0;i<3;i++)
00792
00793 d.Extension[i] = vlab[8+i];
00794 d.Attributes = ATTR_VOLUME_ID | ATTR_ARCHIVE;
00795 d.NTRes = 0;
00796 d.CrtTimeTenth = 0;
00797 d.CrtTime=0;
00798 d.CrtDate=0;
00799 d.LstAccDate=0;
00800 d.FstClusHI=0;
00801 d.WrtTime=form_time();
00802 d.WrtDate=form_date();
00803 d.FstClusLO=0;
00804 d.FileSize=0;
00805 res = write_dir(&d,0,ROOT_SEC);
00806 if(res != 0)
00807 return E_DISK;
00808 printf(" %d %%\r",100);
00809 printf("\nFormat Complete.\n");
00810 return 0;
00811 }
00812 int get_next_sector(int sec)
00813 {
00814 int cluster = sec - DATA_SEC + 2;
00815 int next_clu,next_sec;
00816 printf("sec : %d",sec);
00817 if(sec >= ROOT_SEC && sec < DATA_SEC)
00818 if(sec+1 < DATA_SEC)
00819 return sec+1;
00820 else
00821 return EOF1;
00822 read_fat(&next_clu,cluster,FAT1_SEC);
00823 printf("cluster : %d\n",cluster);
00824 if(EOF(next_clu))
00825 return next_clu;
00826 next_sec = next_clu -2 + DATA_SEC;
00827 return next_sec;
00828 }
00829 int get_free_sector(int prev)
00830 {
00831 unsigned char a[512];
00832 int fat1,fat2,fat_entry,fat_in,in,res,next_sec;
00833 if(prev < DATA_SEC)
00834 return EOF1;
00835 if(!EOF(prev))
00836 prev = prev - DATA_SEC +2;
00837 else
00838 prev = 0;
00839 next_sec = prev*3/2;
00840 next_sec = FAT1_SEC+ next_sec/512;
00841 if(read_sector(next_sec,a) != 0)
00842 return EOF1;
00843
00844 for(in=prev;in<MAX_BLOCK;in++)
00845 {
00846 fat_in = (in*3)/2;
00847 if(fat_in % 512 == 511)
00848 {
00849
00850 fat1 = a[511];
00851 res = read_sector(next_sec+1,a);
00852 if(res != 0)
00853 return EOF1;
00854 next_sec++;
00855 fat2 = a[0];
00856 }
00857 else
00858 {
00859 fat_in = fat_in%512;
00860 fat1 = a[fat_in] & 0xff;
00861 fat2 = a[fat_in+1] & 0xff;
00862 }
00863 parse_fat(&fat_entry,fat1,fat2,in);
00864 if(fat_entry == 0)
00865 return (in + DATA_SEC -2);
00866 }
00867 return EOF1;
00868 }
00869 int get_free_entry(int *sec,int no_ent)
00870 {
00871 int st_sec,i,j,unused,u,u_sec,u_ent,prev_sec;
00872 unsigned char a[512];
00873 st_sec = *sec;
00874 unused = 0;
00875 u = 0;
00876 while(1)
00877 {
00878 if(read_sector(*sec,a) != 0)
00879 return E_DISK;
00880 for(i=0;i<16;i++)
00881
00882 {
00883 if(unused != 0 && a[i*32] != 0xE5)
00884 unused =0;
00885
00886 if(a[i*32] == 0x0)
00887 return i;
00888 else if(a[i*32] == 0xE5)
00889 {
00890 if(!unused)
00891 {
00892 u = 0;
00893 u_ent = i;
00894 u_sec = *sec;
00895 unused = 1;
00896 }
00897 u++;
00898 if(u >= no_ent)
00899 {
00900 *sec = u_sec;
00901 return u_ent;
00902 }
00903 printf("unused : %d u:%d u_ent : %d\n",unused,u,u_ent);
00904 }
00905 }
00906 *sec = get_next_sector(*sec);
00907 if(EOF(*sec))
00908 {
00909 if(st_sec == ROOT_SEC)
00910 break;
00911 else
00912 {
00913 prev_sec = *sec;
00914 *sec = get_free_sector(*sec);
00915 if(!EOF(*sec))
00916 {
00917 write_fat(*sec-DATA_SEC +2,prev_sec - DATA_SEC + 2,FAT1_SEC);
00918 write_fat(*sec-DATA_SEC +2,prev_sec - DATA_SEC + 2,FAT2_SEC);
00919 write_fat(EOF1,*sec-DATA_SEC +2,FAT1_SEC);
00920 write_fat(EOF1,*sec-DATA_SEC +2,FAT2_SEC);
00921 }
00922 else
00923 break;
00924 }
00925 }
00926 }
00927 return E_DISK;
00928 }
00929
00930 int remove_chain(long clu)
00931 {
00932 long fat1,fat2,fat_entry,fat_in,in,res,next_sec;
00933 int prev_sec;
00934 unsigned char a[512];
00935
00936
00937 if(clu == 0 || EOF(clu))
00938 return 0;
00939
00940 prev_sec = (clu*3)/2;
00941 prev_sec = FAT1_SEC+ prev_sec/512;
00942
00943 in = clu;
00944 printf("next fat : %d prev_Sec %d",in,prev_sec);
00945
00946 if(read_sector(prev_sec,a) != 0)
00947 return E_DISK;
00948
00949 while(!EOF(in))
00950 {
00951 fat_in = (in*3)/2;
00952 next_sec = FAT1_SEC+ fat_in/512;
00953
00954
00955 if(next_sec != prev_sec)
00956 {
00957 prev_sec = next_sec;
00958 if(read_sector(next_sec,a) != 0)
00959 return E_DISK;
00960 }
00961
00962 if(fat_in % 512 == 511)
00963 {
00964
00965 fat1 = a[511];
00966 res = read_sector(next_sec+1,a);
00967 if(res != 0)
00968 return EOF1;
00969 prev_sec = next_sec+1;
00970 fat2 = a[0];
00971 }
00972 else
00973 {
00974 fat_in = fat_in%512;
00975 fat1 = a[fat_in] & 0xff;
00976 fat2 = a[fat_in+1] & 0xff;
00977 }
00978 parse_fat(&fat_entry,fat1,fat2,in);
00979 if(fat_entry == 0)
00980 return E_DISK;
00981 write_fat(0,in,FAT1_SEC);
00982 write_fat(0,in,FAT2_SEC);
00983 printf("next fat : %d",in);
00984 in = fat_entry;
00985 }
00986 return 0;
00987 }
00988 int get_long_name(char *long_name,unsigned char *a,int j,int *prev_sec,int cur)
00989 {
00990 int i,k,sec,in_long,lo_len;
00991 struct long_dir_entry lo;
00992 struct dir_entry rs;
00993 char name[15];
00994 char chksum;
00995 unsigned char b[512];
00996 sec = prev_sec[cur];
00997 parse_dir(a,j,&rs);
00998 for(i=0;i<8;i++)
00999 name[i] = rs.Filename[i];
01000 for(;i<12;i++)
01001 name[i] = rs.Extension[i-8];
01002 name[i] = '\0';
01003 printf("%s",name);
01004 for(i=0;i<512;i++)
01005 b[i] = a[i];
01006 chksum = ChkSum(name);
01007 in_long = 0;
01008 i = j;
01009 printf("i = %d sec = %d chksum = %d",i,sec,chksum);
01010 lo_len = 0;
01011 long_name[lo_len] = '\0';
01012 while(1)
01013 {
01014 i--;
01015 if(i == -1)
01016 {
01017 cur--;
01018 sec = prev_sec[cur];
01019 printf("sec %d cur%d",sec,cur);
01020 if(cur < 0)
01021 return E_DISK;
01022 if(read_sector(sec,b) != 0)
01023 return E_DISK;
01024 i = 15;
01025 }
01026 parse_long_dir(&lo,b,i);
01027 print_long_dir(&lo);
01028 printf("long_len %d\n",lo_len);
01029 if((lo.LDIR_Chksum != chksum) || (lo.LDIR_Attr & ATTR_LONG_NAME != ATTR_LONG_NAME))
01030 return E_DISK;
01031 else
01032 {
01033 in_long++;
01034 if(lo.LDIR_Ord & 0x40)
01035 {
01036 for(k=0;k<10;k++)
01037 {
01038 if((lo.LDIR_Name1[k] == 0x00) && (lo.LDIR_Name1[k+1] == 0x00))
01039 break;
01040 if((lo.LDIR_Name1[k] == 0xFF) && (lo.LDIR_Name1[k+1] == 0xFF))
01041 break;
01042 else if(k%2 ==0)
01043 long_name[lo_len++] = lo.LDIR_Name1[k];
01044 }
01045 for(k=0;k<12;k++)
01046 {
01047 if((lo.LDIR_Name2[k] == 0x00) && (lo.LDIR_Name2[k+1] == 0x00))
01048 break;
01049 if((lo.LDIR_Name2[k] == 0xFF) && (lo.LDIR_Name2[k+1] == 0xFF))
01050 break;
01051 else if(k%2 ==0)
01052 long_name[lo_len++] = lo.LDIR_Name2[k];
01053 }
01054 for(k=0;k<4;k++)
01055 {
01056 if((lo.LDIR_Name3[k] == 0x00) && (lo.LDIR_Name3[k+1] == 0x00))
01057 break;
01058 if((lo.LDIR_Name3[k] == 0xFF) && (lo.LDIR_Name3[k+1] == 0xFF))
01059 break;
01060 else if(k%2 ==0)
01061 long_name[lo_len++] = lo.LDIR_Name3[k];
01062 }
01063 long_name[lo_len] = '\0';
01064 printf("%s %d",long_name,lo_len);
01065 return 0;
01066 }
01067 else if(lo.LDIR_Ord == in_long)
01068 {
01069 for(k=0;k<10;k++)
01070 {
01071 if(k%2 ==0)
01072 long_name[lo_len++] = lo.LDIR_Name1[k];
01073
01074 }
01075 for(k=0;k<12;k++)
01076 {
01077 if(k%2 ==0)
01078 long_name[lo_len++] = lo.LDIR_Name2[k];
01079 }
01080 for(k=0;k<4;k++)
01081 {
01082 if(k%2 ==0)
01083 long_name[lo_len++] = lo.LDIR_Name3[k];
01084 }
01085 }
01086 else
01087 return E_DISK;
01088 }
01089 }
01090 }
01091 int rem_long_name(unsigned char *a,int j,int *prev_sec,int *c)
01092 {
01093 int i,k,sec,in_long;
01094 struct long_dir_entry lo;
01095 struct dir_entry rs;
01096 char name[15];
01097 char chksum;
01098 int cur = *c;
01099 unsigned char b[512];
01100
01101
01102 sec = prev_sec[cur];
01103 parse_dir(a,j,&rs);
01104
01105
01106 for(i=0;i<8;i++)
01107 name[i] = rs.Filename[i];
01108 for(;i<12;i++)
01109 name[i] = rs.Extension[i-8];
01110 name[i] = '\0';
01111 printf("%s",name);
01112 for(i=0;i<512;i++)
01113 b[i] = a[i];
01114 chksum = ChkSum(name);
01115 in_long = 0;
01116 i = j;
01117 printf("i = %d sec = %d chksum = %d",i,sec,chksum);
01118 while(1)
01119 {
01120 i--;
01121 if(i == -1)
01122 {
01123 cur--;
01124 sec = prev_sec[cur];
01125 printf("sec %d cur%d",sec,cur);
01126 if(cur < 0)
01127 return 0;
01128 if(read_sector(sec,b) != 0)
01129 return E_DISK;
01130 i = 15;
01131 }
01132 parse_long_dir(&lo,b,i);
01133 print_long_dir(&lo);
01134 if((lo.LDIR_Chksum != chksum) || (lo.LDIR_Attr & ATTR_LONG_NAME != ATTR_LONG_NAME))
01135 return 0;
01136 else
01137 {
01138 in_long++;
01139
01140 if(lo.LDIR_Ord & 0x40)
01141 {
01142 lo.LDIR_Ord = 0xE5;
01143 printf("\nfinal long: sec %d in %d",sec,i);
01144 if(write_long_dir(&lo,i,sec) != 0)
01145 return E_DISK;
01146 return 0;
01147 }
01148 else if(lo.LDIR_Ord == in_long)
01149 {
01150
01151 lo.LDIR_Ord = 0xE5;
01152
01153 printf("\nlong: sec %d in %d",sec,i);
01154 if(write_long_dir(&lo,i,sec) != 0)
01155 return E_DISK;
01156 }
01157 else
01158 return 0;
01159 }
01160 }
01161 }
01162
01163 int search(char *name,struct sector sec,struct dir_entry *rs,int *root_sec,int *root_in,int *prev_sec,int *s_cur)
01164 {
01165 int i,j,res,m,n,k,next_sec,found = 0,p,no_sec,q;
01166 unsigned char a[512],name1[15],long_name[255];
01167 int cur;
01168 if(strlen(name) <= 0)
01169 return -1;
01170 no_sec = sec.base;
01171 next_sec = sec.base;
01172 cur = 0;
01173 prev_sec[cur] = sec.base;
01174 cur++;
01175 printf("search:");
01176 while(!found)
01177 {
01178 printf("next_sec: %d",next_sec);
01179 res = read_sector(next_sec,a);
01180 if(res != 0)
01181 return E_DISK;
01182 for(j=0;j<16 && !found;j++)
01183 {
01184 printf("j = %d a = %d %x first: %x\n",j,a[j*32+11],a[j*32+11],a[j*32]);
01185 if(a[j*32] == 0xE5)
01186 continue;
01187 else if(a[j*32] == 0)
01188 return E_FS_NEXISTS;
01189 else
01190 {
01191 if(((a[j*32+11] & ATTR_LONG_NAME) == 0) && ((a[j*32+11] & ATTR_VOLUME_ID) == 0))
01192 {
01193 printf("yes %d\n",strlen(name));
01194 parse_dir(a,j,rs);
01195 print_dir(rs);
01196 if(strlen(name) <= 12)
01197 {
01198 strcpy(name1,rs->Filename);
01199 for(p=0;p<8;p++)
01200 if(name1[p]== 32)
01201 break;
01202 name1[p++] = '.';
01203 for(q=0;q<3;q++,p++)
01204 {
01205 if(rs->Extension[q] == ' ')
01206 break;
01207 name1[p] = rs->Extension[q];
01208 }
01209 if(q == 0)
01210 p--;
01211 name1[p] = '\0';
01212 cls();
01213 printf("Name1 : %s\n",name1);
01214 printf("Name : %s\n",name);
01215 if(stricmp(name,name1) == 0)
01216 {
01217 found = 1;
01218 *root_sec = next_sec;
01219 *root_in = j;
01220 *s_cur = cur - 1;
01221 break;
01222 }
01223 }
01224 if(get_long_name(long_name,a,j,prev_sec,cur-1) == 0)
01225 {
01226 cls();
01227 printf("Name : %s \n",name);
01228 printf("LongName : %s\n",long_name);
01229 if(stricmp(long_name,name) == 0)
01230 {
01231 found = 1;
01232 *root_sec = next_sec;
01233 *root_in = j;
01234 *s_cur = cur-1;
01235 break;
01236 }
01237 }
01238 }
01239 }
01240
01241 }
01242 if(found)
01243 break;
01244 next_sec = get_next_sector(next_sec);
01245 if(EOF(next_sec))
01246 break;
01247 prev_sec[cur++] = next_sec;
01248 }
01249 if(!found)
01250 return E_FS_NEXISTS;
01251 return 0;
01252 }
01253 int get_part(char *name,int i)
01254 {
01255 int j;
01256 for(j=i;j<strlen(name);j++)
01257 if(name[j] == '\\')
01258 return j;
01259 return j;
01260 }
01261
01262 int get_dir_entry(char * dirname,struct dir_entry *rs,int *root_sec,int *root_in,int *prev,int *cur)
01263 {
01264 int len,i,j,k,res;
01265 struct sector sec;
01266 char name[256];
01267 len = strlen(dirname);
01268 if(dirname[0] ='\\')
01269 {
01270 sec.base = ROOT_SEC;
01271 sec.length = 14;
01272 }
01273 else
01274 {
01275 return E_FS_NEXISTS;
01276 }
01277 i=0;
01278 printf("len :%d ",len);
01279 while(i < len)
01280 {
01281 j=i+1;
01282 i = get_part(dirname,i+1);
01283 printf("i = %d",i);
01284 for(k=0;j<i;j++,k++)
01285 name[k]=dirname[j];
01286 name[k] = '\0';
01287 cli();
01288 printf("name : %s",name);
01289
01290 sti();
01291 res = search(name,sec,rs,root_sec,root_in,prev,cur);
01292
01293 if(res != 0)
01294 return res;
01295 else
01296 {
01297 if(i < len)
01298 {
01299 if(rs->Attributes != ATTR_DIRECTORY)
01300 return E_FS_NEXISTS;
01301 sec.base = rs->FstClusLO +DATA_SEC - 2;
01302 if(sec.base == 0)
01303 sec.base = ROOT_SEC;
01304 sec.length = rs->FileSize/512;
01305 }
01306 }
01307 }
01308 print_dir(rs);
01309 printf("cur %d\n",*cur);
01310 printf("res %d\n",res);
01311 return 0;
01312 }
01313 int do_open(int pid,char *fname,int mode)
01314 {
01315 int i,res,root_sec,root_in,cur;
01316 struct dir_entry rs;
01317 int prev[14];
01318 for(i=0;i<MAX_FILE;i++)
01319 if(fd[pid][i].avl == 1)
01320 break;
01321 if(i == MAX_FILE)
01322 return E_FS_BUSY;
01323 strcpy(fd[pid][i].fname,fname);
01324 fd[pid][i].mode = mode;
01325 res = get_dir_entry(fname,&rs,&root_sec,&root_in,prev,&cur);
01326 if(res != 0)
01327 {
01328 fd[pid][i].avl = 1;
01329 return res;
01330 }
01331 fd[pid][i].sec_offset= (rs.FstClusHI << 16 | rs.FstClusLO);
01332 if(fd[pid][i].sec_offset == 0)
01333 fd[pid][i].sec_offset = EOF1;
01334 else
01335 {
01336 fd[pid][i].sec_offset= DATA_SEC -2 + fd[pid][i].sec_offset;
01337 if(read_sector(fd[pid][i].sec_offset,fd[pid][i].buffer) != 0)
01338 {
01339 fd[pid][i].avl = 1;
01340 return E_DISK;
01341 }
01342 }
01343 fd[pid][i].offset= 0;
01344 fd[pid][i].tot_offset=0;
01345 fd[pid][i].length = rs.FileSize;
01346 fd[pid][i].rs = rs;
01347 fd[pid][i].root_sec = root_sec;
01348 fd[pid][i].root_in = root_in;
01349 fd[pid][i].avl = 0;
01350 cli();
01351 printf("root_sec %d root_in %d",fd[pid][i].root_sec,fd[pid][i].root_in);
01352
01353 sti();
01354 return i;
01355 }
01356
01357 int do_opendir(int pid,char *fname)
01358 {
01359 int i,res,root_sec,root_in,cur;
01360 struct dir_entry rs;
01361 int prev[14];
01362 for(i=0;i<MAX_FILE;i++)
01363 if(dd[pid][i].avl == 1)
01364 break;
01365 if(i == MAX_DIR)
01366 return E_FS_BUSY;
01367 strcpy(dd[pid][i].fname,fname);
01368 res = get_dir_entry(fname,&rs,&root_sec,&root_in,prev,&cur);
01369 if(res != 0 || ((rs.Attributes & ATTR_DIRECTORY) != ATTR_DIRECTORY))
01370 {
01371 if(strcmp(fname,"\\") == 0)
01372 {
01373 dd[pid][i].offset = 0;
01374 dd[pid][i].sec_offset = ROOT_SEC;
01375 dd[pid][i].avl = 0;
01376 if(read_sector(dd[pid][i].sec_offset,dd[pid][i].buffer) != 0)
01377 {
01378 dd[pid][i].avl = 1;
01379 return E_DISK;
01380 }
01381 return i;
01382 }
01383 else
01384 {
01385 dd[pid][i].avl = 1;
01386 return E_DISK;
01387 }
01388 }
01389 dd[pid][i].sec_offset= (rs.FstClusHI << 16) | rs.FstClusLO;
01390 printf("sec %d\n",dd[pid][i].sec_offset);
01391
01392 if(dd[pid][i].sec_offset == 0)
01393 dd[pid][i].sec_offset = EOF1;
01394 else
01395 {
01396 dd[pid][i].sec_offset= DATA_SEC -2 + dd[pid][i].sec_offset;
01397 if(read_sector(dd[pid][i].sec_offset,dd[pid][i].buffer) != 0)
01398 {
01399 dd[pid][i].avl = 1;
01400 return E_DISK;
01401 }
01402 }
01403 dd[pid][i].offset= 0;
01404 dd[pid][i].avl = 0;
01405 return i;
01406 }
01407
01408 int do_read(int pid,int fd_in,char *buf,int length)
01409 {
01410 long i,j,k,prev_sec;
01411 cli();
01412 printf("read : fd_in %d\n",fd_in);
01413
01414 sti();
01415 j=0;
01416 if(fd[pid][fd_in].avl == 1)
01417 return E_DISK;
01418 if(EOF(fd[pid][fd_in].sec_offset))
01419 return j;
01420 if(fd[pid][fd_in].offset == 512)
01421 {
01422 prev_sec = fd[pid][fd_in].sec_offset;
01423 if(fd[pid][fd_in].mode == O_RDWR)
01424 write_sector(prev_sec,fd[pid][fd_in].buffer);
01425 fd[pid][fd_in].sec_offset = get_next_sector(fd[pid][fd_in].sec_offset);
01426 printf("next: %d ",fd[pid][fd_in].sec_offset);
01427 if(fd[pid][fd_in].sec_offset >= EOF1 && fd[pid][fd_in].sec_offset <= EOF2)
01428 return j;
01429 read_sector(fd[pid][fd_in].sec_offset,fd[pid][fd_in].buffer);
01430 fd[pid][fd_in].offset = 0;
01431 }
01432
01433 while(1)
01434 {
01435 for(k=fd[pid][fd_in].tot_offset,i=fd[pid][fd_in].offset;i<512 && j<length && k < fd[pid][fd_in].length;j++,i++,k++)
01436 buf[j] = fd[pid][fd_in].buffer[i];
01437 fd[pid][fd_in].offset = i;
01438 fd[pid][fd_in].tot_offset = k;
01439 if(k >= fd[pid][fd_in].length && j < length)
01440 {
01441 return j;
01442 }
01443
01444 if(j < length )
01445 {
01446 prev_sec = fd[pid][fd_in].sec_offset;
01447 if(fd[pid][fd_in].mode == O_RDWR && !EOF(prev_sec))
01448 write_sector(prev_sec,fd[pid][fd_in].buffer);
01449 fd[pid][fd_in].sec_offset = get_next_sector(fd[pid][fd_in].sec_offset);
01450
01451 if(EOF(fd[pid][fd_in].sec_offset))
01452 return j;
01453 read_sector(fd[pid][fd_in].sec_offset,fd[pid][fd_in].buffer);
01454 fd[pid][fd_in].offset = 0;
01455 }
01456 else
01457 return j;
01458 }
01459 }
01460
01461 int do_readdir(int pid,int dd_in,DIRENT *dir)
01462 {
01463 long i,j,k,prev,length,next_sec;
01464 int cur,prev_sec[14],p,q;
01465 char name[15],long_name[255];
01466 struct dir_entry rs;
01467 DATE dt;
01468 j=0;
01469 length = 32;
01470 cur = 0;
01471 prev_sec[cur] = dd[pid][dd_in].sec_offset;
01472 cur++;
01473
01474 if(dd[pid][dd_in].avl == 1)
01475 return E_DISK;
01476 if(EOF(dd[pid][dd_in].sec_offset))
01477 return E_DISK;
01478 if(dd[pid][dd_in].offset == 512)
01479 {
01480 dd[pid][dd_in].sec_offset = get_next_sector(dd[pid][dd_in].sec_offset);
01481 printf("next: %d ",dd[pid][dd_in].sec_offset);
01482 if(dd[pid][dd_in].sec_offset >= EOF1 && dd[pid][dd_in].sec_offset <= EOF2)
01483 return E_DISK;
01484 if(read_sector(dd[pid][dd_in].sec_offset,dd[pid][dd_in].buffer) != 0)
01485 return E_DISK;
01486 dd[pid][dd_in].offset = 0;
01487 }
01488 while(1)
01489 {
01490 j = dd[pid][dd_in].offset/32;
01491
01492 for(;j<16;j++)
01493 {
01494 printf("\n%d %d",j,dd[pid][dd_in].buffer[j*32]);
01495 if(dd[pid][dd_in].buffer[j*32] == 0xE5)
01496 continue;
01497 else if(dd[pid][dd_in].buffer[j*32] == 0)
01498 {
01499 dd[pid][dd_in].offset = j*32;
01500 return E_DISK;
01501 }
01502 else
01503 {
01504 if((dd[pid][dd_in].buffer[j*32+11] & ATTR_LONG_NAME) == 0)
01505 {
01506 parse_dir(dd[pid][dd_in].buffer,j,&rs);
01507 strcpy(name,rs.Filename);
01508 for(p=0;p<8;p++)
01509 if(name[p]== 32)
01510 break;
01511 name[p++] = '.';
01512 for(q=0;q<3;q++,p++)
01513 {
01514 if(rs.Extension[q] == ' ')
01515 break;
01516 name[p] = rs.Extension[q];
01517 }
01518 if(q == 0)
01519 p--;
01520 name[p] = '\0';
01521
01522 strcpy(dir->name,name);
01523 dir->clu = (rs.FstClusHI << 16) + rs.FstClusLO;
01524 dir->attribute = rs.Attributes;
01525 get_date(rs.CrtDate,&dir->crt_dt);
01526 get_time(rs.CrtTime,&dir->crt_time);
01527 get_date(rs.LstAccDate,&dir->acc_dt);
01528 get_date(rs.WrtDate,&dir->mod_dt);
01529 get_time(rs.WrtTime,&dir->mod_time);
01530 dir->size = rs.FileSize;
01531
01532 if((dd[pid][dd_in].buffer[j*32+11] & ATTR_VOLUME_ID) == 0)
01533 {
01534 if(get_long_name(long_name,dd[pid][dd_in].buffer,j,prev_sec,cur-1) == 0)
01535 {
01536 strcpy(dir->name,long_name);
01537 }
01538 }
01539 dd[pid][dd_in].offset = (j+1)*32;
01540 return 0;
01541 }
01542 }
01543 }
01544
01545 dd[pid][dd_in].sec_offset = get_next_sector(dd[pid][dd_in].sec_offset);
01546 dd[pid][dd_in].offset = 0;
01547 if(read_sector(dd[pid][dd_in].sec_offset,dd[pid][dd_in].buffer) != 0)
01548 return E_DISK;
01549 if(EOF(dd[pid][dd_in].sec_offset))
01550 break;
01551 prev_sec[cur++] = dd[pid][dd_in].sec_offset;
01552 }
01553 dd[pid][dd_in].offset = (j+1)*32;
01554 return E_DISK;
01555 }
01556 int do_write(int pid,int fd_in,char *buf,int length)
01557 {
01558 long i,j,k;
01559 int temp;
01560 int prev_sec;
01561 j=0;
01562 if(fd[pid][fd_in].avl == 1 || fd[pid][fd_in].mode == O_RDONLY)
01563 return E_DISK;
01564 prev_sec = fd[pid][fd_in].sec_offset;
01565 if(fd[pid][fd_in].offset == 512 && !EOF(fd[pid][fd_in].sec_offset))
01566 {
01567 fd[pid][fd_in].sec_offset = get_next_sector(fd[pid][fd_in].sec_offset);
01568 printf("next: %d %d\n",fd[pid][fd_in].sec_offset,prev_sec);
01569 if(!EOF(prev_sec))
01570 write_sector(prev_sec,fd[pid][fd_in].buffer);
01571 if(!EOF(fd[pid][fd_in].sec_offset))
01572 {
01573 read_sector(fd[pid][fd_in].sec_offset,fd[pid][fd_in].buffer);
01574 fd[pid][fd_in].offset = 0;
01575 }
01576 }
01577
01578 if(EOF(fd[pid][fd_in].sec_offset))
01579 {
01580 fd[pid][fd_in].sec_offset = get_free_sector(prev_sec);
01581 printf("next free: %d\n",fd[pid][fd_in].sec_offset);
01582 if(!EOF(fd[pid][fd_in].sec_offset))
01583 {
01584 if(!EOF(prev_sec))
01585 {
01586 write_fat(fd[pid][fd_in].sec_offset-DATA_SEC +2,prev_sec - DATA_SEC + 2,FAT1_SEC);
01587 write_fat(fd[pid][fd_in].sec_offset-DATA_SEC +2,prev_sec - DATA_SEC + 2,FAT2_SEC);
01588 }
01589 else
01590 {
01591 fd[pid][fd_in].rs.FstClusLO = (fd[pid][fd_in].sec_offset - DATA_SEC + 2) & 0xFFFF;
01592 fd[pid][fd_in].rs.FstClusHI = (fd[pid][fd_in].sec_offset - DATA_SEC + 2) >> 16;
01593 }
01594 write_fat(EOF1,fd[pid][fd_in].sec_offset-DATA_SEC +2,FAT1_SEC);
01595 write_fat(EOF1,fd[pid][fd_in].sec_offset-DATA_SEC +2,FAT2_SEC);
01596 }
01597 else
01598 {
01599 if(!EOF(prev_sec) && prev_sec > DATA_SEC)
01600 {
01601 write_fat(EOF1,prev_sec - DATA_SEC + 2,FAT1_SEC);
01602 write_fat(EOF1,prev_sec - DATA_SEC + 2,FAT2_SEC);
01603 }
01604 return j;
01605 }
01606 fd[pid][fd_in].offset = 0;
01607 }
01608 while(1)
01609 {
01610 for(k=fd[pid][fd_in].tot_offset,i=fd[pid][fd_in].offset;i<512 && j<length;j++,i++,k++)
01611 fd[pid][fd_in].buffer[i] = buf[j];
01612 fd[pid][fd_in].offset = i;
01613 fd[pid][fd_in].tot_offset = k;
01614 if(fd[pid][fd_in].length < k)
01615 fd[pid][fd_in].length = k;
01616
01617 if(j < length )
01618 {
01619 prev_sec = fd[pid][fd_in].sec_offset;
01620 fd[pid][fd_in].sec_offset = get_next_sector(fd[pid][fd_in].sec_offset);
01621
01622 if(!EOF(prev_sec))
01623 write_sector(prev_sec,fd[pid][fd_in].buffer);
01624 if(EOF(fd[pid][fd_in].sec_offset))
01625 {
01626 fd[pid][fd_in].sec_offset = get_free_sector(prev_sec);
01627
01628 if(!EOF(fd[pid][fd_in].sec_offset))
01629 {
01630 if(!EOF(prev_sec))
01631 {
01632 write_fat(fd[pid][fd_in].sec_offset-DATA_SEC +2,prev_sec - DATA_SEC + 2,FAT1_SEC);
01633 write_fat(fd[pid][fd_in].sec_offset-DATA_SEC +2,prev_sec - DATA_SEC + 2,FAT2_SEC);
01634 }
01635 else
01636 {
01637 fd[pid][fd_in].rs.FstClusLO = (fd[pid][fd_in].sec_offset - DATA_SEC + 2) && 0xFFFF;
01638 fd[pid][fd_in].rs.FstClusHI = (fd[pid][fd_in].sec_offset - DATA_SEC + 2) >> 16;
01639 }
01640 write_fat(EOF1,fd[pid][fd_in].sec_offset- DATA_SEC + 2,FAT1_SEC);
01641 write_fat(EOF1,fd[pid][fd_in].sec_offset- DATA_SEC + 2,FAT2_SEC);
01642 }
01643 else
01644 {
01645 if(!EOF(prev_sec) && prev_sec > DATA_SEC)
01646 {
01647 write_fat(EOF1,prev_sec - DATA_SEC + 2,FAT1_SEC);
01648 write_fat(EOF1,prev_sec - DATA_SEC + 2,FAT2_SEC);
01649 }
01650 return j;
01651 }
01652 }
01653 else
01654 read_sector(fd[pid][fd_in].sec_offset,fd[pid][fd_in].buffer);
01655 fd[pid][fd_in].offset = 0;
01656 }
01657 else
01658 {
01659 return j;
01660 }
01661 }
01662 }
01663
01664 int do_close(int pid,int fd_in)
01665 {
01666 int res;
01667 if(fd[pid][fd_in].avl == 1)
01668 return E_DISK;
01669 if(fd[pid][fd_in].mode == O_RDWR && !EOF(fd[pid][fd_in].sec_offset))
01670 {
01671 if((res= write_sector(fd[pid][fd_in].sec_offset,fd[pid][fd_in].buffer)) != 0)
01672 return E_DISK;
01673 printf("result of close : %d %d",fd[pid][fd_in].sec_offset,res);
01674 fd[pid][fd_in].rs.FileSize = fd[pid][fd_in].length;
01675 fd[pid][fd_in].rs.WrtDate = form_date();
01676 fd[pid][fd_in].rs.WrtTime = form_time();
01677 }
01678 fd[pid][fd_in].rs.LstAccDate = form_date();
01679
01680
01681
01682
01683
01684 write_dir(&fd[pid][fd_in].rs,fd[pid][fd_in].root_in,fd[pid][fd_in].root_sec);
01685 fd[pid][fd_in].avl = 1;
01686 return 0;
01687 }
01688 int do_closedir(int pid,int dd_in)
01689 {
01690 dd[pid][dd_in].avl = 1;
01691 return 0;
01692 }
01693 int do_create(int pid,char *name,int is_dir)
01694 {
01695 int len,i,j,k,p,is_long,ord,lg,name_len,sh_len,pres,m,sh_in,temp_j,ext_len,dir_sec,dir_ent,no_dig,chksum,no_ent,no_sec,dir_sec_t[10],free_sec,res;
01696 char fname[255],sh_name[14],ext[4],sh_w[9],no[9],dirname[255],tmp_name[255];
01697 struct dir_entry rs,dot_ent,ddot_ent;
01698 struct long_dir_entry ld;
01699 int prev[14],cur;
01700
01701 len = strlen(name);
01702 for(i=len-1;i>=0;i--)
01703 if(name[i] == '\\')
01704 break;
01705 for(j=0;j<i;j++)
01706 dirname[j] = name[j];
01707 dirname[j] = '\0';
01708 if(strlen(dirname) == 0)
01709 strcpy(dirname,"\\");
01710 is_long = 0;
01711 for(j=i+1;j<len;j++)
01712 {
01713 fname[j-i-1] = name[j];
01714 if(name[j] == ' ')
01715 is_long =1;
01716 }
01717 fname[j-i-1] = '\0';
01718
01719 if(strlen(fname) > 255)
01720 return E_FS_FNAME;
01721
01722 printf("%s %s %s %d\n",name,fname,dirname,is_long);
01723 if((p = do_open(pid,name,O_RDONLY)) >= 0)
01724 {
01725 do_close(pid,p);
01726 return E_FS_EXISTS;
01727 }
01728
01729 if(strcmp(dirname,"\\") == 0)
01730 {
01731 dir_sec = ROOT_SEC;
01732 }
01733 else
01734 {
01735 if((res= get_dir_entry(dirname,&rs,&dir_sec,&i,prev,&cur)) != 0)
01736 return res;
01737 if(rs.Attributes != ATTR_DIRECTORY)
01738 return E_FS_NEXISTS;
01739 dir_sec = DATA_SEC -2 + (rs.FstClusHI << 16 | rs.FstClusLO);
01740 }
01741 no_ent = strlen(fname);
01742 no_ent = no_ent%13 ? no_ent/13+1: no_ent/13;
01743 printf("no_ent : %d\n",no_ent);
01744 if( (dir_ent = get_free_entry(&dir_sec,no_ent+1)) == -1)
01745 return E_FS_SPACE;
01746 printf("dir_ent : %d\n",dir_ent);
01747 for(k=0,j=0;k<8 && j<strlen(fname);j++)
01748 {
01749 if(fname[j] == '.')
01750 break;
01751 if(fname[j] != ' ')
01752 {
01753 sh_name[k] = fname[j];
01754 k++;
01755 }
01756 }
01757 sh_in = k;
01758 sh_name[k] = '\0';
01759 for(j=strlen(fname);j>=0;j--)
01760 {
01761 if(fname[j] == '.')
01762 break;
01763 }
01764 if(j < 0)
01765 j = strlen(fname) - 1;
01766 m=j;
01767 for(j++,k=0;k<3 && j<strlen(fname);j++)
01768 {
01769 if(fname[j] != ' ')
01770 {
01771 ext[k] = fname[j];
01772 k++;
01773 }
01774 }
01775 for(;k<3;k++)
01776 ext[k] = ' ';
01777 ext[k] ='\0';
01778 name_len = m;
01779 ext_len = strlen(fname) - m -1;
01780 if(name_len > 8)
01781 is_long = 1;
01782 else
01783 {
01784 if(ext_len > 4)
01785 is_long =1;
01786 }
01787 printf("\n%d %s %s %s %d %d",is_long,sh_name,ext,fname,name_len,ext_len);
01788 if(is_long == 1)
01789 {
01790 pres =1;
01791 j=1;
01792 while(pres)
01793 {
01794 pres =1;
01795 if(j > 256)
01796 return E_FS_FNAME;
01797 temp_j = j;
01798 for(m=0;temp_j > 0;m++)
01799 {
01800 no[m] = '0' + temp_j%10;
01801 temp_j = temp_j/10;
01802 }
01803 no[m] = '\0';
01804 no_dig = strlen(no);
01805 sh_len= 8 - no_dig -1;
01806 for(k=0,m=0;k<sh_len && k < sh_in;k++)
01807 sh_w[k] = sh_name[k];
01808 sh_w[k++] = '~';
01809 for(m=strlen(no) - 1;m>=0;m--,k++)
01810 sh_w[k] = no[m];
01811
01812 sh_w[k] = '\0';
01813 j++;
01814 strcpy(tmp_name,"");
01815 strcat(tmp_name,dirname);
01816 strcat(tmp_name,sh_w);
01817 if(ext[0] != ' ')
01818 {
01819 strcat(tmp_name,".");
01820 strcat(tmp_name,ext);
01821 }
01822 printf("\ntmp = %s %s\n",tmp_name,sh_w);
01823 if((p = do_open(pid,tmp_name,O_RDONLY)) >= 0)
01824 do_close(pid,p);
01825 else
01826 pres = 0;
01827 printf("p = %d pres = %d\n",p,pres);
01828
01829 printf("\nShort name : %s",sh_w);
01830 }
01831 }
01832 else
01833 {
01834 sh_name[sh_in] = '\0';
01835 strcpy(sh_w,sh_name);
01836 }
01837 rs.CrtDate = form_date();
01838 rs.CrtTime = form_time();
01839 rs.LstAccDate = form_date();
01840 rs.WrtDate = rs.CrtDate;
01841 rs.WrtTime = rs.CrtTime;
01842 rs.NTRes = 0;
01843 rs.FileSize = 0;
01844 rs.CrtTimeTenth = 0;
01845
01846 if(is_dir)
01847 {
01848 free_sec = get_free_sector(EOF1);
01849 if(clear_sec(free_sec) != 0)
01850 return E_DISK;
01851 if(EOF(free_sec))
01852 return E_FS_SPACE;
01853 if(write_fat(EOF2,free_sec - DATA_SEC + 2,FAT1_SEC) != 0)
01854 return E_DISK;
01855 if(write_fat(EOF2,free_sec - DATA_SEC + 2,FAT2_SEC) != 0)
01856 return E_DISK;
01857
01858 rs.Attributes = ATTR_DIRECTORY;
01859 rs.FstClusLO = (free_sec - DATA_SEC + 2) & 0xFFFF;
01860 rs.FstClusHI = (free_sec - DATA_SEC + 2) >> 16;
01861
01862 dot_ent = rs;
01863 dot_ent.Filename[0] = '.';
01864 for(i=1;i<8;i++)
01865 dot_ent.Filename[i] = ' ';
01866 for(i=0;i<3;i++)
01867 dot_ent.Extension[i] = ' ';
01868 if(write_dir(&dot_ent,0,free_sec) != 0)
01869 return E_DISK;
01870
01871 ddot_ent = rs;
01872 if(dir_sec >= ROOT_SEC && dir_sec < DATA_SEC)
01873 {
01874 ddot_ent.FstClusHI = 0;
01875 ddot_ent.FstClusLO =0;
01876 }
01877 else
01878 {
01879 ddot_ent.FstClusLO = (dir_sec -DATA_SEC + 2) & 0xFFFF;
01880 ddot_ent.FstClusHI = (dir_sec -DATA_SEC +2) >> 16;
01881
01882 }
01883
01884 ddot_ent.Filename[0] = '.';
01885 ddot_ent.Filename[1] = '.';
01886 for(i=2;i<8;i++)
01887 ddot_ent.Filename[i] = ' ';
01888 for(i=0;i<3;i++)
01889 ddot_ent.Extension[i] = ' ';
01890 if(write_dir(&ddot_ent,1,free_sec) != 0)
01891 return E_DISK;
01892
01893 print_dir(&dot_ent);
01894 print_dir(&ddot_ent);
01895 }
01896 else
01897 {
01898 rs.Attributes = ATTR_ARCHIVE;
01899 rs.FstClusHI = 0;
01900 rs.FstClusLO = 0;
01901 }
01902
01903 for(i=0;i<strlen(sh_w);i++)
01904 {
01905 if(sh_w[i] == ' ')
01906 break;
01907 else
01908 rs.Filename[i] = toupper(sh_w[i]);
01909 }
01910 for(;i<8;i++)
01911 rs.Filename[i] = ' ';
01912
01913 for(i=0;i<strlen(ext);i++)
01914 {
01915 if(sh_w[i] == ' ')
01916 break;
01917 else
01918 rs.Extension[i] = toupper(ext[i]);
01919 }
01920 for(;i<3;i++)
01921 rs.Extension[i] = ' ';
01922
01923 no_sec = dir_ent+no_ent;
01924 dir_sec_t[0] = dir_sec;
01925 i=0;
01926 while(no_sec >= 16)
01927 {
01928 i++;
01929
01930 dir_sec_t[i] = get_next_sector(dir_sec_t[i-1]);
01931 no_sec = no_sec -16;
01932 }
01933 print_dir(&rs);
01934 printf("sh_ent %d %d %d %d",(dir_ent+no_ent)%16,dir_ent,no_ent,dir_sec_t[i]);
01935 if(write_dir(&rs,(dir_ent+no_ent)%16,dir_sec_t[i]) != 0)
01936 return E_DISK;
01937 j=0;
01938 for(k=0;k<8;k++)
01939 sh_name[k] = rs.Filename[k];
01940 for(;k<12;k++)
01941 sh_name[k] = rs.Extension[k-8];
01942 sh_name[k] = '\0';
01943 chksum = ChkSum(sh_name);
01944
01945 ld.LDIR_Attr = ATTR_LONG_NAME;
01946 ld.LDIR_Chksum = chksum;
01947 ld.LDIR_FstClusLO = 0;
01948 ld.LDIR_Type = 0;
01949 ord = 1;
01950 lg =0;
01951 while(j < strlen(fname))
01952 {
01953 if(strlen(fname) - j <= 13)
01954 ord = ord | 0x40;
01955
01956 ld.LDIR_Ord = ord;
01957 for(k=0;k<5 && j<strlen(fname);k++,j++)
01958 {
01959 ld.LDIR_Name1[k*2] = fname[j];
01960 ld.LDIR_Name1[k*2+1] = 0;
01961 }
01962
01963 for(;k<5;k++)
01964 {
01965 if(lg == 1)
01966 {
01967 ld.LDIR_Name1[k*2] = 0xFF;
01968 ld.LDIR_Name1[k*2+1] = 0xFF;
01969 }
01970 else
01971 {
01972 lg = 1;
01973 ld.LDIR_Name1[k*2] = 0;
01974 ld.LDIR_Name1[k*2+1] = 0;
01975 }
01976 }
01977 for(k=0;k<6 && j<strlen(fname);k++,j++)
01978 {
01979 ld.LDIR_Name2[k*2] = fname[j];
01980 ld.LDIR_Name2[k*2+1] = 0;
01981 }
01982
01983 for(;k<6;k++)
01984 {
01985 if(lg == 1)
01986 {
01987 ld.LDIR_Name2[k*2] = 0xFF;
01988 ld.LDIR_Name2[k*2+1] = 0xFF;
01989 }
01990 else
01991 {
01992 ld.LDIR_Name2[k*2] = 0;
01993 ld.LDIR_Name2[k*2+1] = 0;
01994 lg = 1;
01995 }
01996 }
01997 for(k=0;k<2 && j<strlen(fname);k++,j++)
01998 {
01999 ld.LDIR_Name3[k*2] = fname[j];
02000 ld.LDIR_Name3[k*2+1] = 0;
02001 }
02002 for(;k<2;k++)
02003 {
02004
02005 if(lg == 1)
02006 {
02007 ld.LDIR_Name3[k*2] = 0xFF;
02008 ld.LDIR_Name3[k*2+1] = 0xFF;
02009 }
02010 else
02011 {
02012 ld.LDIR_Name3[k*2] = 0;
02013 ld.LDIR_Name3[k*2+1] = 0;
02014 lg = 1;
02015 }
02016 }
02017 ord++;
02018 dir_ent--;
02019 if(dir_ent+no_ent > 16)
02020 i--;
02021 if(write_long_dir(&ld,(dir_ent+no_ent)%16,dir_sec_t[i]) != 0)
02022 return E_DISK;
02023 printf("%d %d",dir_sec_t[i],dir_ent+no_ent);
02024 print_long_dir(&ld);
02025 }
02026 return 0;
02027 }
02028 int fs_create(int pid,char *name)
02029 {
02030 return do_create(pid,name,0);
02031 }
02032 int do_createdir(int pid,char *name)
02033 {
02034 return do_create(pid,name,1);
02035 }
02036
02037 int do_remove(int pid,char *name)
02038 {
02039 int sec,in,prev[14],cur,dir;
02040 long clu;
02041 struct dir_entry rs;
02042 DIRENT ds;
02043 unsigned char a[512],name1[255];
02044
02045
02046 if(get_dir_entry(name,&rs,&sec,&in,prev,&cur) != 0)
02047 return E_DISK;
02048
02049 if((rs.Attributes & ATTR_DIRECTORY) == ATTR_DIRECTORY)
02050 {
02051 dir = do_opendir(pid,name);
02052 printf("dir : %d",dir);
02053 if(dir < 0)
02054 return E_DISK;
02055
02056 while(do_readdir(pid,dir,&ds) == 0)
02057 {
02058 if((strcmp(ds.name,".") != 0) && (strcmp(ds.name,"..") != 0))
02059 {
02060 print_DIRENT(&ds);
02061 strcpy(name1,name);
02062 strcat(name1,"\\");
02063 strcat(name1,ds.name);
02064 do_remove(pid,name1);
02065 }
02066 }
02067 do_closedir(pid,dir);
02068 }
02069
02070 if(read_sector(sec,a) != 0)
02071 return E_DISK;
02072
02073 printf("\nsector is %d",sec);
02074 printf("\ncur %d",cur);
02075
02076 if(rem_long_name(a,in,prev,&cur) != 0)
02077 return E_DISK;
02078
02079
02080
02081 if(read_dir(&rs,in,sec) != 0)
02082 return E_DISK;
02083
02084 clu = (rs.FstClusHI << 16) | rs.FstClusLO;
02085
02086 rs.Filename[0] = 0xE5;
02087 if(write_dir(&rs,in,sec) != 0)
02088 return E_DISK;
02089
02090 if(remove_chain(clu) != 0)
02091 return E_DISK;
02092 return 0;
02093
02094 }
02095 int do_rename(int pid,char *name1,char *name)
02096 {
02097 int sec,in,prev[14],cur;
02098 int rsec,rin,rprev[14],rcur;
02099 unsigned char a[512];
02100 int len,i,j,k,p,is_long,ord,lg,name_len,sh_len,pres,m,sh_in,temp_j,ext_len,dir_sec,dir_ent,no_dig,chksum,no_ent,no_sec,dir_sec_t[10];
02101 char fname[255],sh_name[14],ext[4],sh_w[9],no[9],dirname[255],tmp_name[255];
02102 struct dir_entry rs;
02103 struct long_dir_entry ld;
02104
02105
02106 if(get_dir_entry(name1,&rs,&rsec,&rin,rprev,&rcur) != 0)
02107 return E_FS_NEXISTS;
02108
02109 len = strlen(name);
02110 for(i=len-1;i>=0;i--)
02111 if(name[i] == '\\')
02112 break;
02113 for(j=0;j<i;j++)
02114 dirname[j] = name[j];
02115 dirname[j] = '\0';
02116 if(strlen(dirname) == 0)
02117 strcpy(dirname,"\\");
02118
02119 is_long = 0;
02120
02121 for(j=i+1;j<len;j++)
02122 {
02123 fname[j-i-1] = name[j];
02124 if(name[j] == ' ')
02125 is_long =1;
02126 }
02127 fname[j-i-1] = '\0';
02128
02129 if(strlen(fname) > 255)
02130 return E_FS_FNAME;
02131
02132 printf("%s %s %s %d\n",name,fname,dirname,is_long);
02133 if((p = do_open(pid,name,O_RDONLY)) >= 0)
02134 {
02135 do_close(pid,p);
02136 return E_FS_EXISTS;
02137 }
02138
02139 if(strcmp(dirname,"\\") == 0)
02140 {
02141 dir_sec = ROOT_SEC;
02142 }
02143 else
02144 {
02145 if( get_dir_entry(dirname,&rs,&dir_sec,&i,prev,&cur) != 0)
02146 return E_FS_NEXISTS;
02147 if(rs.Attributes != ATTR_DIRECTORY)
02148 return E_FS_NEXISTS;
02149 dir_sec = DATA_SEC -2 + (rs.FstClusHI << 16 | rs.FstClusLO);
02150 }
02151
02152 no_ent = strlen(fname);
02153 no_ent = no_ent%13 ? no_ent/13+1: no_ent/13;
02154 printf("no_ent : %d\n",no_ent);
02155 if((dir_ent = get_free_entry(&dir_sec,no_ent+1)) == -1)
02156 return E_FS_SPACE;
02157 printf("dir_ent : %d\n",dir_ent);
02158 for(k=0,j=0;k<8 && j<strlen(fname);j++)
02159 {
02160 if(fname[j] == '.')
02161 break;
02162 if(fname[j] != ' ')
02163 {
02164 sh_name[k] = fname[j];
02165 k++;
02166 }
02167 }
02168 sh_in = k;
02169 sh_name[k] = '\0';
02170 for(j=strlen(fname);j>=0;j--)
02171
02172 {
02173 if(fname[j] == '.')
02174 break;
02175 }
02176 if(j < 0)
02177 j = strlen(fname) - 1;
02178 m=j;
02179 for(j++,k=0;k<3 && j<strlen(fname);j++)
02180 {
02181 if(fname[j] != ' ')
02182 {
02183 ext[k] = fname[j];
02184 k++;
02185 }
02186 }
02187 for(;k<3;k++)
02188 ext[k] = ' ';
02189 ext[k] ='\0';
02190 name_len = m;
02191 ext_len = strlen(fname) - m -1;
02192 if(name_len > 8)
02193 is_long = 1;
02194 else
02195 {
02196 if(ext_len > 4)
02197 is_long =1;
02198 }
02199 printf("\n%d %s %s %s %d %d",is_long,sh_name,ext,fname,name_len,ext_len);
02200 if(is_long == 1)
02201 {
02202 pres =1;
02203 j=1;
02204 while(pres)
02205 {
02206 pres =1;
02207 if(j > 256)
02208 return E_FS_EXISTS;
02209 temp_j = j;
02210 for(m=0;temp_j > 0;m++)
02211 {
02212 no[m] = '0' + temp_j%10;
02213 temp_j = temp_j/10;
02214 }
02215 no[m] = '\0';
02216 no_dig = strlen(no);
02217 sh_len= 8 - no_dig -1;
02218 for(k=0,m=0;k<sh_len && k < sh_in;k++)
02219 sh_w[k] = sh_name[k];
02220 sh_w[k++] = '~';
02221 for(m=strlen(no) - 1;m>=0;m--,k++)
02222 sh_w[k] = no[m];
02223 sh_w[k] = '\0';
02224 j++;
02225 strcpy(tmp_name,"");
02226
02227 strcat(tmp_name,dirname);
02228 strcat(tmp_name,sh_w);
02229 if(ext[0] != ' ')
02230 {
02231 strcat(tmp_name,".");
02232 strcat(tmp_name,ext);
02233 }
02234 printf("\ntmp = %s %s\n",tmp_name,sh_w);
02235 if((p = do_open(pid,tmp_name,O_RDONLY)) >= 0)
02236 do_close(pid,p);
02237 else
02238 pres = 0;
02239 printf("p = %d pres = %d\n",p,pres);
02240 printf("\nShort name : %s",sh_w);
02241 }
02242 }
02243 else
02244 {
02245 sh_name[sh_in] = '\0';
02246 strcpy(sh_w,sh_name);
02247 }
02248 if(read_sector(rsec,a) != 0)
02249 return E_DISK;
02250
02251 printf("\nsector is %d",rsec);
02252 printf("\ncur %d",rcur);
02253
02254 if(rem_long_name(a,rin,rprev,&rcur) != 0)
02255 return E_DISK;
02256
02257
02258
02259 if(read_dir(&rs,rin,rsec) != 0)
02260 return E_DISK;
02261
02262 rs.Filename[0] = 0xE5;
02263 if(write_dir(&rs,rin,rsec) != 0)
02264 return E_DISK;
02265 rs.LstAccDate = form_date();
02266
02267 for(i=0;i<strlen(sh_w);i++)
02268 {
02269 if(sh_w[i] == ' ')
02270 break;
02271 else
02272 rs.Filename[i] = toupper(sh_w[i]);
02273 }
02274 for(;i<8;i++)
02275 rs.Filename[i] = ' ';
02276
02277 for(i=0;i<strlen(ext);i++)
02278 {
02279 if(sh_w[i] == ' ')
02280 break;
02281 else
02282 rs.Extension[i] = toupper(ext[i]);
02283 }
02284 for(;i<3;i++)
02285 rs.Extension[i] = ' ';
02286 no_sec = dir_ent+no_ent;
02287 dir_sec_t[0] = dir_sec;
02288 i=0;
02289 while(no_sec >= 16)
02290 {
02291 i++;
02292 dir_sec_t[i] = get_next_sector(dir_sec_t[i-1]);
02293 no_sec = no_sec -16;
02294 }
02295 print_dir(&rs);
02296 printf("sh_ent %d %d %d %d",(dir_ent+no_ent)%16,dir_ent,no_ent,dir_sec_t[i]);
02297 if(write_dir(&rs,(dir_ent+no_ent)%16,dir_sec_t[i]) != 0)
02298 return E_DISK;
02299 j=0;
02300 for(k=0;k<8;k++)
02301 sh_name[k] = rs.Filename[k];
02302 for(;k<12;k++)
02303 sh_name[k] = rs.Extension[k-8];
02304 sh_name[k] = '\0';
02305 chksum = ChkSum(sh_name);
02306
02307 ld.LDIR_Attr = ATTR_LONG_NAME;
02308 ld.LDIR_Chksum = chksum;
02309 ld.LDIR_FstClusLO = 0;
02310 ld.LDIR_Type = 0;
02311 ord = 1;
02312 lg =0;
02313 while(j < strlen(fname))
02314 {
02315 if(strlen(fname) - j <= 13)
02316 ord = ord | 0x40;
02317
02318 ld.LDIR_Ord = ord;
02319 for(k=0;k<5 && j<strlen(fname);k++,j++)
02320 {
02321 ld.LDIR_Name1[k*2] = fname[j];
02322 ld.LDIR_Name1[k*2+1] = 0;
02323 }
02324
02325 for(;k<5;k++)
02326 {
02327 if(lg == 1)
02328 {
02329 ld.LDIR_Name1[k*2] = 0xFF;
02330 ld.LDIR_Name1[k*2+1] = 0xFF;
02331 }
02332 else
02333 {
02334 lg = 1;
02335 ld.LDIR_Name1[k*2] = 0;
02336 ld.LDIR_Name1[k*2+1] = 0;
02337 }
02338 }
02339 for(k=0;k<6 && j<strlen(fname);k++,j++)
02340 {
02341 ld.LDIR_Name2[k*2] = fname[j];
02342 ld.LDIR_Name2[k*2+1] = 0;
02343 }
02344
02345 for(;k<6;k++)
02346 {
02347 if(lg == 1)
02348 {
02349 ld.LDIR_Name2[k*2] = 0xFF;
02350 ld.LDIR_Name2[k*2+1] = 0xFF;
02351 }
02352 else
02353 {
02354 ld.LDIR_Name2[k*2] = 0;
02355 ld.LDIR_Name2[k*2+1] = 0;
02356 lg = 1;
02357 }
02358 }
02359 for(k=0;k<2 && j<strlen(fname);k++,j++)
02360 {
02361 ld.LDIR_Name3[k*2] = fname[j];
02362 ld.LDIR_Name3[k*2+1] = 0;
02363 }
02364 for(;k<2;k++)
02365 {
02366 if(lg == 1)
02367 {
02368 ld.LDIR_Name3[k*2] = 0xFF;
02369 ld.LDIR_Name3[k*2+1] = 0xFF;
02370 }
02371 else
02372 {
02373 ld.LDIR_Name3[k*2] = 0;
02374 ld.LDIR_Name3[k*2+1] = 0;
02375 lg = 1;
02376 }
02377 }
02378 ord++;
02379 dir_ent--;
02380 if(dir_ent+no_ent > 16)
02381 i--;
02382 if(write_long_dir(&ld,(dir_ent+no_ent)%16,dir_sec_t[i]) != 0)
02383 return E_DISK;
02384 printf("%d %d",dir_sec_t[i],dir_ent+no_ent);
02385 print_long_dir(&ld);
02386 }
02387
02388 return 0;
02389 }
02390 int do_load(char *fname,int pid)
02391 {
02392 int p,i,res;
02393 long addr;
02394 p = do_open(pid,fname,O_RDONLY);
02395
02396
02397
02398
02399
02400
02401
02402 i= 0;
02403 if(p >= 0)
02404 {
02405 addr = _pgte[pid][i] & 0xFFFFFF80;
02406 while((addr != -1) && (res = do_read(pid,p,addr,4096)) > 0)
02407 {
02408
02410
02411
02412
02413
02414
02415 i++;
02416 addr = _pgte[pid][i] & 0xFFFFFF80;
02417 }
02418 cls();
02419 res = do_close(pid,p);
02420 cli();
02421 printf("\close ret : %d",res);
02422
02423 sti();
02424 return 0;
02425 }
02426 return -1;
02427 }
02428
02429 void fs_init()
02430 {
02431 int i,j;
02432 for(j=0;j<MAX_PROC;j++)
02433 for(i=0;i<MAX_FILE;i++)
02434 fd[j][i].avl = 1;
02435 for(j=0;j<MAX_PROC;j++)
02436 for(i=0;i<MAX_DIR;i++)
02437 dd[j][i].avl = 1;
02438 }
02439
02440 int do_ls(int pid,char *dirname)
02441 {
02442 int p;
02443 DIRENT ds;
02444 p = do_opendir(pid,dirname);
02445 if(p != -1)
02446 {
02447 while(do_readdir(pid,p,&ds) == 0)
02448 print_DIRENT(&ds);
02449 return 0;
02450 }
02451 return -1;
02452 }
02453
02454 int do_copy(int pid,char *src,char *dest)
02455 {
02456 int p,q,res;
02457 char buf[1024];
02458 p = do_open(pid,src,O_RDONLY);
02459 q = do_open(pid,dest,O_RDWR);
02460 if(p < 0 || q < 0)
02461 return -1;
02462 else
02463 {
02464 printf("p = %d q=%d\n",p,q);
02465 while((res = do_read(pid,p,buf,1024)) > 0)
02466 {
02467
02468
02469 if(do_write(pid,q,buf,res) < 0)
02470 return -1;
02471 }
02472 printf("res %d",res);
02473 do_close(pid,p);
02474 do_close(pid,q);
02475 return 0;
02476 }
02477 }
02478 void runFS()
02479 {
02480 int ret_val;
02481 while(1)
02482 {
02483
02484
02485
02486 if(no_fs_req != 0)
02487 {
02488 printf("\nFS running %d",no_fs_req);
02489 printf("type %d fname %s\n",fsreqs[fs_fr_req].type,fsreqs[fs_fr_req].op.fname);
02490
02491
02492
02493
02494 switch(fsreqs[fs_fr_req].type)
02495 {
02496 case OPEN :
02497 ret_val = do_open(fsreqs[fs_fr_req].from_pid,fsreqs[fs_fr_req].op.fname,fsreqs[fs_fr_req].op.mode);
02498 break;
02499 case CLOSE :
02500 ret_val = do_close(fsreqs[fs_fr_req].from_pid,fsreqs[fs_fr_req].cl.fd_in);
02501 break;
02502 case READ :
02503 ret_val = do_read(fsreqs[fs_fr_req].from_pid,fsreqs[fs_fr_req].re.fd_in,fsreqs[fs_fr_req].re.buf,fsreqs[fs_fr_req].re.len);
02504 break;
02505 case WRITE :
02506 ret_val = do_write(fsreqs[fs_fr_req].from_pid,fsreqs[fs_fr_req].wr.fd_in,fsreqs[fs_fr_req].wr.buf,fsreqs[fs_fr_req].wr.len);
02507 break;
02508 case CREATEFIL:
02509 ret_val = fs_create(fsreqs[fs_fr_req].from_pid,fsreqs[fs_fr_req].cr.name);
02510 break;
02511 case OPENDIR:
02512 ret_val = do_opendir(fsreqs[fs_fr_req].from_pid,fsreqs[fs_fr_req].opd.dir_name);
02513 break;
02514 case CREATEDIR:
02515 ret_val = do_createdir(fsreqs[fs_fr_req].from_pid,fsreqs[fs_fr_req].crd.name);
02516 break;
02517 case CLOSEDIR:
02518 ret_val = do_closedir(fsreqs[fs_fr_req].from_pid,fsreqs[fs_fr_req].cld.dd_in);
02519 break;
02520 case READDIR :
02521 ret_val = do_readdir(fsreqs[fs_fr_req].from_pid,fsreqs[fs_fr_req].red.dd_in,fsreqs[fs_fr_req].red.dir);
02522 break;
02523 case REMOVE :
02524 ret_val = do_remove(fsreqs[fs_fr_req].from_pid,fsreqs[fs_fr_req].rem.name);
02525 break;
02526 case RENAME :
02527 ret_val = do_rename(fsreqs[fs_fr_req].from_pid,fsreqs[fs_fr_req].ren.old_name,fsreqs[fs_fr_req].ren.new_name);
02528 break;
02529 case LOAD :
02530 ret_val = do_load(fsreqs[fs_fr_req].load.fname,fsreqs[fs_fr_req].from_pid);
02531 break;
02532 default:
02533 ret_val = E_FS_BADREQ;
02534
02535 }
02536 cli();
02537 printf("ret %d name %s\n",ret_val,fsreqs[fs_fr_req].load.fname);
02538
02539 sti();
02540 asm("pushl %%eax"::"a"(fsreqs[fs_fr_req].type));
02541 asm("pushl %%eax"::"a"(ret_val));
02542 asm("pushl %%eax"::"a"(fsreqs[fs_fr_req].from_pid));
02543 asm("int $0x30"::"a"(12));
02544
02545 fs_fr_req = (fs_fr_req +1) %MAX_FS_REQ;
02546 no_fs_req--;
02547 }
02548 }
02549 }
02550 int addfsreq(fs_request *r)
02551
02552 {
02553 if(no_fs_req == MAX_FS_REQ)
02554 return -1;
02555 memcpy(&fsreqs[fs_en_req],r,sizeof(fsreqs[fs_en_req]));
02556 printf("\n no_req %d id %d",no_fs_req,fsreqs[fs_en_req].cl.fd_in);
02557 fs_en_req = (fs_en_req +1) %MAX_FS_REQ;
02558 no_fs_req++;
02559 return 0;
02560 }
02561
02562 void fscloseAll(DW pid)
02563 {
02564 DW i;
02565 for(i = 0;i<MAX_FILE;i++)
02566 do_close(pid,i);
02567
02568 for(i = 0;i<MAX_DIR;i++)
02569 do_closedir(pid,i);
02570 }
02571
02572
02573
02574
02575
02576
02577
02578
02579
02580
02581
02582
02583
02584
02585
02586
02587
02588
02589
02590
02591
02592
02593
02594
02595
02596
02597
02598
02599
02600
02601
02602
02603
02604
02605
02606
02607
02608
02609
02610
02611
02612
02613
02614
02615
02616
02617
02618
02619
02620
02621
02622
02623
02624
02625
02626
02627
02628
02629
02630
02631
02632
02633
02634
02635
02636
02637
02638
02639
02640
02641
02642
02643
02644
02645
02646
02647
02648
02649
02650
02651
02652
02653
02654
02655
02656
02657
02658
02659
02660
02661
02662
02663
02664
02665
02666
02667
02668
02669
02670
02671
02672
02673
02674
02675
02676
02677
02678
02679
02680
02681
02682
02683
02684
02685
02686
02687
02688
02689
02690
02691
02692
02693
02694
02695
02696
02697
02698
02699
02700
02701
02702
02703
02704
02705
02706
02707
02708
02709
02710
02711
02712
02713
02714
02715
02716
02717
02718
02719
02720
02721
02722
02723
02724
02725
02726
02727
02728
02729
02730
02731
02732
02733
02734
02735
02736
02737
02738
02739
