开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
fat_open.c
资源名称：STM32-uCOS-II_UAV.rar　[点击查看]
上传用户：yj_qqy
上传日期：2017-01-28
资源大小：2911k
文件大小：35k
源码类别：

uCOS

开发平台：

C/C++

fat_open.c：源码内容
  1. /*
  2. **********************************************************************
  3. *                          Micrium, Inc.
  4. *                      949 Crestview Circle
  5. *                     Weston,  FL 33327-1848
  6. *
  7. *                            uC/FS
  8. *
  9. *             (c) Copyright 2001 - 2003, Micrium, Inc.
  10. *                      All rights reserved.
  11. *
  12. ***********************************************************************
  14. ----------------------------------------------------------------------
  15. File        : fat_open.c
  16. Purpose     : FAT routines for open/delete files
  17. ----------------------------------------------------------------------
  18. Known problems or limitations with current version
  19. ----------------------------------------------------------------------
  20. None.
  21. ---------------------------END-OF-HEADER------------------------------
  22. */
  24. /*********************************************************************
  25. *
  26. *             #include Section
  27. *
  28. **********************************************************************
  29. */
  31. #include "fs_conf.h"
  32. #include "fs_port.h"
  33. #ifndef FS_FARCHARPTR
  34. #define FS_FARCHARPTR char *
  35. #endif
  36. #include "fs_dev.h"
  37. #include "fs_api.h"
  38. #include "fs_fsl.h"
  39. #include "fs_int.h"
  40. #include "fs_os.h"
  41. #include "fs_lbl.h"
  42. #include "fs_fat.h"
  43. #include "fs_clib.h"
  46. /*********************************************************************
  47. *
  48. *             #define constants
  49. *
  50. **********************************************************************
  51. */
  53. #ifndef FS_FAT_NOFAT32
  54.   #define FS_FAT_NOFAT32        0
  55. #endif /* FS_FAT_NOFAT32 */
  58. /*********************************************************************
  59. *
  60. *             Local functions
  61. *
  62. **********************************************************************
  63. */
  65. /*********************************************************************
  66. *
  67. *             _FS_fat_find_file
  68. *
  69.   Description:
  70.   FS internal function. Find the file with name pFileName in directory
  71.   DirStart. Copy its directory entry to pDirEntry.
  72.   
  73.   Parameters:
  74.   Idx         - Index of device in the device information table 
  75.                 referred by FS__pDevInfo.
  76.   Unit        - Unit number.
  77.   pFileName   - File name. 
  78.   pDirEntry   - Pointer to an FS__fat_dentry_type data structure.
  79.   DirStart    - 1st cluster of the directory.
  80.   DirSize     - Sector (not cluster) size of the directory.
  81.  
  82.   Return value:
  83.   >=0         - File found. Value is the first cluster of the file.
  84.   <0          - An error has occured.
  85. */
  87. static FS_i32 _FS_fat_find_file(int Idx, FS_u32 Unit, const char *pFileName,
  88.                                     FS__fat_dentry_type *pDirEntry,
  89.                                     FS_u32 DirStart, FS_u32 DirSize) {
  90.   FS__fat_dentry_type *s;
  91.   FS_u32 i;
  92.   FS_u32 dsec;
  93.   int len;
  94.   int err; 
  95.   int c;
  96.   char *buffer;
  98.   buffer = FS__fat_malloc(FS_FAT_SEC_SIZE);
  99.   if (!buffer) {
  100.     return -1;
  101.   }
  102.   len = FS__CLIB_strlen(pFileName);
  103.   if (len > 11) {
  104.     len = 11;
  105.   }
  106.   /* Read directory */
  107.   for (i = 0; i < DirSize; i++) {
  108.     dsec = FS__fat_dir_realsec(Idx, Unit, DirStart, i);
  109.     if (dsec == 0) {
  110.       FS__fat_free(buffer);
  111.       return -1;
  112.     }
  113.     err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, dsec, (void*)buffer);
  114.     if (err < 0) {
  115.       FS__fat_free(buffer);
  116.       return -1;
  117.     }
  118.     s = (FS__fat_dentry_type*)buffer;
  119.     while (1) {
  120.       if (s >= (FS__fat_dentry_type*)(buffer + FS_FAT_SEC_SIZE)) {
  121.         break;  /* End of sector reached */
  122.       }
  123.       c = FS__CLIB_strncmp((char*)s->data, pFileName, len);
  124.       if (c == 0) {  /* Name does match */
  125.         if (s->data[11] & FS_FAT_ATTR_ARCHIVE) {
  126.           break;  /* Entry found */
  127.         }
  128.       }
  129.       s++;
  130.     }
  131.     if (s < (FS__fat_dentry_type*)(buffer + FS_FAT_SEC_SIZE)) {
  132.       /* Entry found. Return number of 1st block of the file */
  133.       if (pDirEntry) {
  134.         FS__CLIB_memcpy(pDirEntry, s, sizeof(FS__fat_dentry_type));
  135.       }
  136.       FS__fat_free(buffer);
  137.       dsec  = (FS_u32)s->data[26];
  138.       dsec += (FS_u32)s->data[27] * 0x100UL;
  139.       dsec += (FS_u32)s->data[20] * 0x10000UL;
  140.       dsec += (FS_u32)s->data[21] * 0x1000000UL;
  141.       return ((FS_i32)dsec);
  142.     }
  143.   }
  144.   FS__fat_free(buffer);
  145.   return -1;
  146. }
  149. /*********************************************************************
  150. *
  151. *             _FS_fat_IncDir
  152. *
  153.   Description:
  154.   FS internal function. Increase directory starting at DirStart.
  155.   
  156.   Parameters:
  157.   Idx         - Index of device in the device information table 
  158.                 referred by FS__pDevInfo.
  159.   Unit        - Unit number.
  160.   DirStart    - 1st cluster of the directory.
  161.   pDirSize    - Pointer to an FS_u32, which is used to return the new 
  162.                 sector (not cluster) size of the directory.
  163.  
  164.   Return value:
  165.   ==1         - Success.
  166.   ==-1        - An error has occured.
  167. */
  169. static int _FS_fat_IncDir(int Idx, FS_u32 Unit, FS_u32 DirStart, FS_u32 *pDirSize) {
  170.   FS_u32 i;
  171.   FS_u32 dsec;
  172.   FS_i32 last;
  173.   char *buffer;
  174.   int err;
  176.   if (DirStart == 0) { 
  177.     /* Increase root directory only, if not FAT12/16  */
  178.     i = FS__FAT_aBPBUnit[Idx][Unit].RootEntCnt;
  179.     if (i != 0) {
  180.       return -1;  /* Not FAT32 */
  181.     }
  182.   }
  183.   last = FS__fat_FAT_find_eof(Idx, Unit, DirStart, 0);
  184.   if (last < 0) {
  185.     return -1;  /* No EOF marker found */
  186.   }
  187.   last = FS__fat_FAT_alloc(Idx, Unit, last);  /* Allocate new cluster */
  188.   if (last < 0) {
  189.     return -1;
  190.   }
  191.   *pDirSize = *pDirSize + FS__FAT_aBPBUnit[Idx][Unit].SecPerClus;
  192.   /* Clean new directory cluster */
  193.   buffer = FS__fat_malloc(FS_FAT_SEC_SIZE);
  194.   if (!buffer) {
  195.     return -1;
  196.   }
  197.   FS__CLIB_memset(buffer, 0x00, (FS_size_t)FS_FAT_SEC_SIZE);
  198.   for (i = *pDirSize - FS__FAT_aBPBUnit[Idx][Unit].SecPerClus; i < *pDirSize; i++) {
  199.     dsec = FS__fat_dir_realsec(Idx, Unit, DirStart, i);
  200.     if (dsec == 0) {
  201.       FS__fat_free(buffer);
  202.       return -1;
  203.     }
  204.     err = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, dsec, (void*)buffer);
  205.     if (err < 0) {
  206.       FS__fat_free(buffer);
  207.       return -1;
  208.     }
  209.   }
  210.   FS__fat_free(buffer);
  211.   return 1;
  212. }
  215. /*********************************************************************
  216. *
  217. *             _FS_fat_create_file
  218. *
  219.   Description:
  220.   FS internal function. Create a file in the directory specified
  221.   with DirStart. Do not call, if you have not checked before for 
  222.   existing file with name pFileName.
  224.   Parameters:
  225.   Idx         - Index of device in the device information table 
  226.                 referred by FS__pDevInfo.
  227.   Unit        - Unit number, which is passed to the device driver.
  228.   pFileName   - File name. 
  229.   DirStart    - Start of directory, where to create pDirName.
  230.   DirSize     - Sector size of the directory starting at DirStart.
  231.   
  232.   Return value:
  233.   >=0         - 1st cluster of the new file.
  234.   ==-1        - An error has occured.
  235.   ==-2        - Cannot create, because directory is full.
  236. */
  238. static FS_i32 _FS_fat_create_file(int Idx, FS_u32 Unit,  const char *pFileName,
  239.                                     FS_u32 DirStart, FS_u32 DirSize) {
  240.   FS__fat_dentry_type *s;
  241.   FS_u32 i;
  242.   FS_u32 dsec;
  243.   FS_i32 cluster;
  244.   int len;
  245.   int err;
  246.   FS_u16 val;
  247.   char *buffer;
  249.   buffer = FS__fat_malloc(FS_FAT_SEC_SIZE);
  250.   if (!buffer) {
  251.     return -1;
  252.   }
  253.   len = FS__CLIB_strlen(pFileName);
  254.   if (len > 11) {
  255.     len = 11;
  256.   }
  257.   /* Read directory */
  258.   for (i = 0; i < DirSize; i++) {
  259.     dsec = FS__fat_dir_realsec(Idx, Unit, DirStart, i);
  260.     if (dsec == 0) {
  261.       FS__fat_free(buffer);
  262.       return -1;
  263.     }
  264.     err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, dsec, (void*)buffer);
  265.     if (err < 0) {
  266.       FS__fat_free(buffer);
  267.       return -1;
  268.     }
  269.     s = (FS__fat_dentry_type*)buffer;
  270.     while (1) {
  271.       if (s >= (FS__fat_dentry_type*)(buffer + FS_FAT_SEC_SIZE)) {
  272.         break;  /* End of sector reached */
  273.       }
  274.       if (s->data[0] == 0x00) {
  275.         break;  /* Empty entry found */
  276.       }
  277.       if (s->data[0] == (unsigned char)0xe5) {
  278.         break;  /* Deleted entry found */
  279.       }
  280.       s++;
  281.     }
  282.     if (s < (FS__fat_dentry_type*)(buffer + FS_FAT_SEC_SIZE)) {
  283.       /* Free entry found. Make entry and return 1st block of the file */
  284.       FS__CLIB_strncpy((char*)s->data, pFileName, len);
  285.       s->data[11] = FS_FAT_ATTR_ARCHIVE;
  286.       /* Alloc block in FAT */
  287.       cluster = FS__fat_FAT_alloc(Idx, Unit, -1);
  288.       if (cluster >= 0) {
  289.         s->data[12]     = 0x00;                           /* Res */
  290.         s->data[13]     = 0x00;                           /* CrtTimeTenth (optional, not supported) */
  291.         s->data[14]     = 0x00;                           /* CrtTime (optional, not supported) */
  292.         s->data[15]     = 0x00;
  293.         s->data[16]     = 0x00;                           /* CrtDate (optional, not supported) */
  294.         s->data[17]     = 0x00;
  295.         s->data[18]     = 0x00;                           /* LstAccDate (optional, not supported) */
  296.         s->data[19]     = 0x00;
  297.         val             = FS_X_OS_GetTime();
  298.         s->data[22]     = (unsigned char)(val & 0xff);   /* WrtTime */
  299.         s->data[23]     = (unsigned char)(val / 256);
  300.         val             = FS_X_OS_GetDate();
  301.         s->data[24]     = (unsigned char)(val & 0xff);   /* WrtDate */
  302.         s->data[25]     = (unsigned char)(val / 256);
  303.         s->data[26]     = (unsigned char)(cluster & 0xff);    /* FstClusLo / FstClusHi */ 
  304.         s->data[27]     = (unsigned char)((cluster / 256) & 0xff);
  305.         s->data[20]     = (unsigned char)((cluster / 0x10000L) & 0xff);
  306.         s->data[21]     = (unsigned char)((cluster / 0x1000000L) & 0xff);
  307.         s->data[28]     = 0x00;                           /* FileSize */
  308.         s->data[29]     = 0x00;
  309.         s->data[30]     = 0x00;
  310.         s->data[31]     = 0x00;
  311.         err = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, dsec, (void*)buffer);
  312.         if (err < 0) {
  313.           FS__fat_free(buffer);
  314.           return -1;
  315.         }
  316.       }
  317.       FS__fat_free(buffer);
  318.       return cluster;
  319.     }
  320.   }
  321.   FS__fat_free(buffer);
  322.   return -2;      /* Directory is full */
  323. }
  326. /*********************************************************************
  327. *
  328. *             Global functions section 1
  329. *
  330. **********************************************************************
  332.   Functions in this section are global, but are used inside the FAT
  333.   File System Layer only.
  334.   
  335. */
  337. /*********************************************************************
  338. *
  339. *             FS__fat_DeleteFileOrDir
  340. *
  341.   Description:
  342.   FS internal function. Delete a file or directory.
  343.   
  344.   Parameters:
  345.   Idx         - Index of device in the device information table 
  346.                 referred by FS__pDevInfo.
  347.   Unit        - Unit number, which is passed to the device driver.
  348.   pName       - File or directory name. 
  349.   DirStart    - Start of directory, where to create pDirName.
  350.   DirSize     - Sector size of the directory starting at DirStart.
  351.   RmFile      - 1 => remove a file
  352.                 0 => remove a directory
  353.   
  354.   Return value:
  355.   >=0         - Success. 
  356.   <0          - An error has occured.
  357. */
  359. FS_i32 FS__fat_DeleteFileOrDir(int Idx, FS_u32 Unit,  const char *pName,
  360.                                     FS_u32 DirStart, FS_u32 DirSize, char RmFile) {
  361.   FS__fat_dentry_type *s;
  362.   FS_u32 dsec;
  363.   FS_u32 i;
  364.   FS_u32 value;
  365.   FS_u32 fatsize;
  366.   FS_u32 filesize;
  367.   FS_i32 len;
  368.   FS_i32 bytespersec;
  369.   FS_i32 fatindex;
  370.   FS_i32 fatsec;
  371.   FS_i32 fatoffs;
  372.   FS_i32 lastsec;
  373.   FS_i32 curclst = 0;
  374.   FS_i32 todo;
  375.   char *buffer;
  376.   int fattype;
  377.   int err;
  378.   int err2;
  379.   int lexp;
  380.   int x;
  381.   unsigned char a;
  382.   unsigned char b;
  383. #if (FS_FAT_NOFAT32==0)
  384.   unsigned char c;
  385.   unsigned char d;
  386. #endif /* FS_FAT_NOFAT32==0 */
  388.   buffer = FS__fat_malloc(FS_FAT_SEC_SIZE);
  389.   if (!buffer) {
  390.     return 0;
  391.   }
  392.   fattype = FS__fat_which_type(Idx, Unit);
  393. #if (FS_FAT_NOFAT32!=0)
  394.   if (fattype == 2) {
  395.     FS__fat_free(buffer);
  396.     return -1;
  397.   }
  398. #endif  /* FS_FAT_NOFAT32!=0 */
  399.   fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz16;
  400.   if (fatsize == 0) {
  401.     fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz32;
  402.   }
  403.   bytespersec = (FS_i32)FS__FAT_aBPBUnit[Idx][Unit].BytesPerSec;
  404.   len = FS__CLIB_strlen(pName);
  405.   if (len > 11) {
  406.     len = 11;
  407.   }
  408.   /* Read directory */
  409.   for (i = 0; i < DirSize; i++) {
  410.     curclst = -1;
  411.     dsec = FS__fat_dir_realsec(Idx, Unit, DirStart, i);
  412.     if (dsec == 0) {
  413.       FS__fat_free(buffer);
  414.       return -1;
  415.     }
  416.     err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, dsec, (void*)buffer);
  417.     if (err < 0) {
  418.       FS__fat_free(buffer);
  419.       return -1;
  420.     }
  421.     /* Scan for pName in the directory sector */
  422.     s = (FS__fat_dentry_type*) buffer;
  423.     while (1) {
  424.       if (s >= (FS__fat_dentry_type*)(buffer + bytespersec)) {
  425.         break;  /* End of sector reached */
  426.       }
  427.       x = FS__CLIB_strncmp((char*)s->data, pName, len);
  428.       if (x == 0) { /* Name does match */
  429.         if (s->data[11] != 0) {
  430.           break;  /* Entry found */
  431.         }
  432.       }
  433.       s++;
  434.     }
  435.     if (s < (FS__fat_dentry_type*)(buffer + bytespersec)) {
  436.       /* Entry has been found, delete directory entry */
  437.       s->data[0]  = 0xe5;
  438.       s->data[11] = 0;
  439.       err = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, dsec, (void*)buffer);
  440.       if (err < 0) {
  441.         FS__fat_free(buffer);
  442.         return -1;
  443.       }
  444.       /* Free blocks in FAT */
  445.       /*
  446.          For normal files, there are no more clusters freed than the entrie's filesize
  447.          does indicate. That avoids corruption of the complete media in case there is
  448.          no EOF mark found for the file (FAT is corrupt!!!). 
  449.          If the function should remove a directory, filesize if always 0 and cannot
  450.          be used for that purpose. To avoid running into endless loop, todo is set
  451.          to 0x0ffffff8L, which is the maximum number of clusters for FAT32.
  452.       */
  453.       if (RmFile) {
  454.         filesize  = s->data[28] + 0x100UL * s->data[29] + 0x10000UL * s->data[30] + 0x1000000UL * s->data[31];
  455.         todo      = filesize / (FS__FAT_aBPBUnit[Idx][Unit].SecPerClus * bytespersec);
  456.         value     = filesize % (FS__FAT_aBPBUnit[Idx][Unit].SecPerClus * bytespersec);
  457.         if (value != 0) {
  458.           todo++;
  459.         }
  460.       } 
  461.       else {
  462.         todo = (FS_i32)0x0ffffff8L;
  463.       }
  464.       curclst = s->data[26] + 0x100L * s->data[27] + 0x10000L * s->data[20] + 0x1000000L * s->data[21];
  465.       lastsec = -1;
  466.       /* Free cluster loop */
  467.       while (todo) {
  468.         if (fattype == 1) {
  469.           fatindex = curclst + (curclst / 2);    /* FAT12 */
  470.         }
  471. #if (FS_FAT_NOFAT32==0)
  472.         else if (fattype == 2) {
  473.           fatindex = curclst * 4;               /* FAT32 */
  474.         }
  475. #endif  /* FS_FAT_NOFAT32==0 */
  476.         else {
  477.           fatindex = curclst * 2;               /* FAT16 */
  478.         }
  479.         fatsec = FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt + (fatindex / bytespersec);
  480.         fatoffs = fatindex % bytespersec;
  481.         if (fatsec != lastsec) {
  482.           err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
  483.           if (err < 0) {
  484.             err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec, (void*)buffer);
  485.             if (err < 0) {
  486.               FS__fat_free(buffer);
  487.               return -1;
  488.             }
  489.             /* Try to repair original FAT sector with contents of copy */
  490.             FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
  491.           }
  492.           lastsec = fatsec;
  493.         }
  494.         if (fattype == 1) {
  495.           if (fatoffs == (bytespersec - 1)) {
  496.             a = buffer[fatoffs];
  497.             if (curclst & 1) {
  498.               buffer[fatoffs] &= 0x0f;
  499.             }
  500.             else {
  501.               buffer[fatoffs]  = 0x00;
  502.             }
  503.             err  = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
  504.             err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec, (void*)buffer);
  505.             lexp = (err < 0);
  506.             lexp = lexp || (err2 < 0);
  507.             if (lexp) {
  508.               FS__fat_free(buffer);
  509.               return -1;
  510.             }
  511.             err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsec + 1, (void*)buffer);
  512.             if (err < 0) {
  513.               err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec + 1, (void*)buffer);
  514.               if (err < 0) {
  515.                 FS__fat_free(buffer);
  516.                 return -1;
  517.               }
  518.               /* Try to repair original FAT sector with contents of copy */
  519.               FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec + 1, (void*)buffer);
  520.             }
  521.             lastsec = fatsec + 1;
  522.             b = buffer[0];
  523.             if (curclst & 1) {
  524.               buffer[0]  = 0x00;;
  525.             }
  526.             else {
  527.               buffer[0] &= 0xf0;
  528.             }
  529.             err  = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec + 1, (void*)buffer);
  530.             err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec + 1, (void*)buffer);
  531.             lexp = (err < 0);
  532.             lexp = lexp || (err2 < 0);
  533.             if (lexp) {
  534.               FS__fat_free(buffer);
  535.               return -1;
  536.             }
  537.           }
  538.           else {
  539.             a = buffer[fatoffs];
  540.             b = buffer[fatoffs + 1];
  541.             if (curclst & 1) {
  542.               buffer[fatoffs]     &= 0x0f;
  543.               buffer[fatoffs + 1]  = 0x00;
  544.             }
  545.             else {
  546.               buffer[fatoffs]      = 0x00;
  547.               buffer[fatoffs + 1] &= 0xf0;
  548.             }
  549.             err  = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
  550.             err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec, (void*)buffer);
  551.             lexp = (err < 0);
  552.             lexp = lexp || (err2 < 0);
  553.             if (lexp) {
  554.               FS__fat_free(buffer);
  555.               return -1;
  556.             }
  557.           }
  558.           if (curclst & 1) {
  559.             curclst = ((a & 0xf0) >> 4) + 16 * b;
  560.           }
  561.           else {
  562.             curclst = a + 256 * (b & 0x0f);
  563.           }
  564.           curclst &= 0x0fff;
  565.           if (curclst >= 0x0ff8) {
  566.             FS__fat_free(buffer);
  567.             return 0;
  568.           }
  569.         }
  570. #if (FS_FAT_NOFAT32==0)
  571.         else if (fattype == 2) { /* FAT32 */
  572.           a = buffer[fatoffs];
  573.           b = buffer[fatoffs + 1];
  574.           c = buffer[fatoffs + 2];
  575.           d = buffer[fatoffs + 3] & 0x0f;
  576.           buffer[fatoffs]      = 0x00;
  577.           buffer[fatoffs + 1]  = 0x00;
  578.           buffer[fatoffs + 2]  = 0x00;
  579.           buffer[fatoffs + 3]  = 0x00;
  580.           err  = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
  581.           err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec, (void*)buffer);
  582.           lexp = (err < 0);
  583.           lexp = lexp || (err2 < 0);
  584.           if (lexp) {
  585.             FS__fat_free(buffer);
  586.             return -1;
  587.           }
  588.           curclst = a + 0x100 * b + 0x10000L * c + 0x1000000L * d;
  589.           curclst &= 0x0fffffffL;
  590.           if (curclst >= (FS_i32)0x0ffffff8L) {
  591.             FS__fat_free(buffer);
  592.             return 0;
  593.           }
  594.         }
  595. #endif /* FS_FAT_NOFAT32==0 */
  596.         else {
  597.           a = buffer[fatoffs];
  598.           b = buffer[fatoffs + 1];
  599.           buffer[fatoffs]     = 0x00;
  600.           buffer[fatoffs + 1] = 0x00;
  601.           err  = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsec, (void*)buffer);
  602.           err2 = FS__lb_write(FS__pDevInfo[Idx].devdriver, Unit, fatsize + fatsec, (void*)buffer);
  603.           lexp = (err < 0);
  604.           lexp = lexp || (err2 < 0);
  605.           if (lexp) {
  606.             FS__fat_free(buffer);
  607.             return -1;
  608.           }
  609.           curclst  = a + 256 * b;
  610.           curclst &= 0xffff;
  611.           if (curclst >= (FS_i32)0xfff8) {
  612.             FS__fat_free(buffer);
  613.             return 0;
  614.           }
  615.         }
  616.         todo--;
  617.       } /* Free cluster loop */
  618.     } /*  Delete entry */
  619.     if (curclst > 0) {
  620.       FS__fat_free(buffer);
  621.       return curclst;
  622.     }
  623.   } /* for */
  624.   FS__fat_free(buffer);
  625.   return curclst;
  626. }
  629. /*********************************************************************
  630. *
  631. *             FS__fat_make_realname
  632. *
  633.   Description:
  634.   FS internal function. Convert a given name to the format, which is
  635.   used in the FAT directory.
  636.   
  637.   Parameters:
  638.   pOrgName    - Pointer to name to be translated
  639.   pEntryName  - Pointer to a buffer for storing the real name used
  640.                 in a directory.
  642.   Return value:
  643.   None.
  644. */
  646. void FS__fat_make_realname(char *pEntryName, const char *pOrgName) {
  647.   FS_FARCHARPTR ext;
  648.   FS_FARCHARPTR s;
  649.   int i;
  651.   s = (FS_FARCHARPTR)pOrgName;
  652.   ext = (FS_FARCHARPTR) FS__CLIB_strchr(s, '.');
  653.   if (!ext) {
  654.     ext = &s[FS__CLIB_strlen(s)];
  655.   }
  656.   i=0;
  657.   while (1) {
  658.     if (s >= ext) {
  659.       break;  /* '.' reached */
  660.     }
  661.     if (i >= 8) {
  662.       break;  /* If there is no '.', this is the end of the name */
  663.     }
  664.     if (*s == (char)0xe5) {
  665.       pEntryName[i] = 0x05;
  666.     }
  667.     else {
  668.       pEntryName[i] = (char)FS__CLIB_toupper(*s);
  669.     }
  670.     i++;
  671.     s++;
  672.   }
  673.   while (i < 8) {
  674.     /* Fill name with spaces*/
  675.     pEntryName[i] = ' ';
  676.     i++;
  677.   }
  678.   if (*s == '.') {
  679.     s++;
  680.   }
  681.   while (i < 11) {
  682.     if (*s != 0) {
  683.       if (*s == (char)0xe5) {
  684.         pEntryName[i] = 0x05;
  685.       }
  686.       else {
  687.         pEntryName[i] = (char)FS__CLIB_toupper(*s);
  688.       }
  689.       s++;
  690.     }
  691.     else {
  692.       pEntryName[i] = ' ';
  693.     }
  694.     i++;
  695.   }
  696.   pEntryName[11]=0;
  697. }
  700. /*********************************************************************
  701. *
  702. *             FS__fat_find_dir
  703. *
  704.   Description:
  705.   FS internal function. Find the directory with name pDirName in directory
  706.   DirStart.
  707.   
  708.   Parameters:
  709.   Idx         - Index of device in the device information table 
  710.                 referred by FS__pDevInfo.
  711.   Unit        - Unit number.
  712.   pDirName    - Directory name; if zero, return the root directory.
  713.   DirStart    - 1st cluster of the directory.
  714.   DirSize     - Sector (not cluster) size of the directory.
  715.  
  716.   Return value:
  717.   >0          - Directory found. Value is the first cluster of the file.
  718.   ==0         - An error has occured.
  719. */
  721. FS_u32 FS__fat_find_dir(int Idx, FS_u32 Unit, char *pDirName, FS_u32 DirStart, 
  722.                         FS_u32 DirSize) {
  723.   FS__fat_dentry_type *s;
  724.   FS_u32 dstart;
  725.   FS_u32 i;
  726.   FS_u32 dsec;
  727.   FS_u32 fatsize;
  728.   int len;
  729.   int err;
  730.   int c;
  731.   char *buffer;
  733.   if (pDirName == 0) {
  734.     /* Return root directory */
  735.     if (FS__FAT_aBPBUnit[Idx][Unit].FATSz16) {
  736.       fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz16;
  737.       dstart  = FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt + FS__FAT_aBPBUnit[Idx][Unit].NumFATs * fatsize;
  738.     }
  739.     else {
  740.       fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz32;
  741.       dstart  = FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt + FS__FAT_aBPBUnit[Idx][Unit].NumFATs * fatsize
  742.                 + (FS__FAT_aBPBUnit[Idx][Unit].RootClus - 2) * FS__FAT_aBPBUnit[Idx][Unit].SecPerClus;
  743.     }
  744.   }
  745.   else {
  746.     /* Find directory */
  747.     buffer = FS__fat_malloc(FS_FAT_SEC_SIZE);
  748.     if (!buffer) {
  749.       return 0;
  750.     }
  751.     len = FS__CLIB_strlen(pDirName);
  752.     if (len > 11) {
  753.       len = 11;
  754.     }
  755.     /* Read directory */
  756.     for (i = 0; i < DirSize; i++) {
  757.       dsec = FS__fat_dir_realsec(Idx, Unit, DirStart, i);
  758.       if (dsec == 0) {
  759.         FS__fat_free(buffer);
  760.         return 0;
  761.       }
  762.       err = FS__lb_read(FS__pDevInfo[Idx].devdriver, Unit, dsec, (void*)buffer);
  763.       if (err < 0) {
  764.         FS__fat_free(buffer);
  765.         return 0;
  766.       }
  767.       s = (FS__fat_dentry_type*)buffer;
  768.       while (1) {
  769.         if (s >= (FS__fat_dentry_type*)(buffer + FS_FAT_SEC_SIZE)) {
  770.           break;  /* End of sector reached */
  771.         }
  772.         c = FS__CLIB_strncmp((char*)s->data, pDirName, len);
  773.         if (c == 0) { /* Name does match */
  774.           if (s->data[11] & FS_FAT_ATTR_DIRECTORY) {
  775.             break;  /* Entry found */
  776.           }
  777.         }
  778.         s++;
  779.       }
  780.       if (s < (FS__fat_dentry_type*)(buffer + FS_FAT_SEC_SIZE)) {
  781.         /* Entry found. Return number of 1st block of the directory */
  782.         FS__fat_free(buffer);
  783.         dstart  = (FS_u32)s->data[26];
  784.         dstart += (FS_u32)0x100UL * s->data[27];
  785.         dstart += (FS_u32)0x10000UL * s->data[20];
  786.         dstart += (FS_u32)0x1000000UL * s->data[21];
  787.         return dstart;
  788.       }
  789.     }
  790.     dstart = 0;
  791.     FS__fat_free(buffer);
  792.   }
  793.   return dstart;
  794. }
  797. /*********************************************************************
  798. *
  799. *             FS__fat_dir_realsec
  800. *
  801.   Description:
  802.   FS internal function. Translate a directory relative sector number
  803.   to a real sector number on the media.
  804.   
  805.   Parameters:
  806.   Idx         - Index of device in the device information table 
  807.                 referred by FS__pDevInfo.
  808.   Unit        - Unit number.
  809.   DirStart    - 1st cluster of the directory. This is zero to address 
  810.                 the root directory. 
  811.   DirSec      - Sector in the directory.
  812.  
  813.   Return value:
  814.   >0          - Directory found. Value is the sector number on the media.
  815.   ==0         - An error has occured.
  816. */
  818. FS_u32 FS__fat_dir_realsec(int Idx, FS_u32 Unit, FS_u32 DirStart, FS_u32 DirSec) {
  819.   FS_u32 rootdir;
  820.   FS_u32 rsec;
  821.   FS_u32 dclust;
  822.   FS_u32 fatsize;
  823.   int fattype;
  824.   int lexp;
  825.   unsigned char secperclus;
  827.   fattype = FS__fat_which_type(Idx, Unit);
  828.   lexp = (0 == DirStart);
  829.   lexp = lexp && (fattype != 2);
  830.   if (lexp) {
  831.     /* Sector in FAT12/FAT16 root directory */
  832.     rootdir = FS__fat_find_dir(Idx, Unit, 0, 0, 0);
  833.     rsec = rootdir + DirSec;
  834.   }
  835.   else {
  836.     fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz16;
  837.     if (fatsize == 0) {
  838.       fatsize = FS__FAT_aBPBUnit[Idx][Unit].FATSz32;
  839.     }
  840.     secperclus = FS__FAT_aBPBUnit[Idx][Unit].SecPerClus;
  841.     dclust = DirSec / secperclus;
  842.     if (0 == DirStart) {
  843.       /* FAT32 root directory */
  844.       rsec = FS__FAT_aBPBUnit[Idx][Unit].RootClus;
  845.     } 
  846.     else {
  847.       rsec = FS__fat_diskclust(Idx, Unit, DirStart, dclust);
  848.       if (rsec == 0) {
  849.         return 0;
  850.       }
  851.     }
  852.     rsec -= 2;
  853.     rsec *= secperclus;
  854.     rsec += FS__FAT_aBPBUnit[Idx][Unit].RsvdSecCnt + FS__FAT_aBPBUnit[Idx][Unit].NumFATs * fatsize;
  855.     rsec += ((FS_u32)((FS_u32)FS__FAT_aBPBUnit[Idx][Unit].RootEntCnt) * FS_FAT_DENTRY_SIZE) / FS_FAT_SEC_SIZE;
  856.     rsec += (DirSec % secperclus);
  857.   }
  858.   return rsec;
  859. }
  862. /*********************************************************************
  863. *
  864. *             FS__fat_dirsize
  865. *
  866.   Description:
  867.   FS internal function. Return the sector size of the directory 
  868.   starting at DirStart.
  869.   
  870.   Parameters:
  871.   Idx         - Index of device in the device information table 
  872.                 referred by FS__pDevInfo.
  873.   Unit        - Unit number.
  874.   DirStart    - 1st cluster of the directory. This is zero to address 
  875.                 the root directory. 
  876.  
  877.   Return value:
  878.   >0          - Sector (not cluster) size of the directory.
  879.   ==0         - An error has occured.
  880. */
  882. FS_u32 FS__fat_dir_size(int Idx, FS_u32 Unit, FS_u32 DirStart) {
  883.   FS_u32 dsize;
  884.   FS_i32 value;
  886.   if (DirStart == 0) {
  887.     /* For FAT12/FAT16 root directory, the size can be found in BPB */
  888.     dsize = ((FS_u32)((FS_u32)FS__FAT_aBPBUnit[Idx][Unit].RootEntCnt)
  889.             * FS_FAT_DENTRY_SIZE) / ((FS_u32)FS__FAT_aBPBUnit[Idx][Unit].BytesPerSec);
  890.     if (dsize == 0) {
  891.       /* Size in BPB is 0, so it is a FAT32 (FAT32 does not have a real root dir) */
  892.       value = FS__fat_FAT_find_eof(Idx, Unit, FS__FAT_aBPBUnit[Idx][Unit].RootClus, &dsize);
  893.       if (value < 0) {
  894.         dsize = 0;
  895.       }
  896.       else {
  897.         dsize *= FS__FAT_aBPBUnit[Idx][Unit].SecPerClus;
  898.       }
  899.     }
  900.   }
  901.   else {
  902.     /* Calc size of a sub-dir */
  903.     value = FS__fat_FAT_find_eof(Idx, Unit, DirStart, &dsize);
  904.     if (value < 0) {
  905.       dsize = 0;
  906.     }
  907.     else {
  908.       dsize *= FS__FAT_aBPBUnit[Idx][Unit].SecPerClus;
  909.     }
  910.   }
  911.   return dsize;
  912. }
  915. /*********************************************************************
  916. *
  917. *             FS__fat_findpath
  918. *
  919.   Description:
  920.   FS internal function. Return start cluster and size of the directory
  921.   of the file name in pFileName.
  922.   
  923.   Parameters:
  924.   Idx         - Index of device in the device information table 
  925.                 referred by FS__pDevInfo.
  926.   pFullName   - Fully qualified file name w/o device name.
  927.   pFileName   - Pointer to a pointer, which is modified to point to the
  928.                 file name part of pFullName.
  929.   pUnit       - Pointer to an FS_u32 for returning the unit number.
  930.   pDirStart   - Pointer to an FS_u32 for returning the start cluster of
  931.                 the directory.
  933.   Return value:
  934.   >0          - Sector (not cluster) size of the directory.
  935.   ==0         - An error has occured.
  936. */
  938. FS_u32 FS__fat_findpath(int Idx, const char *pFullName, FS_FARCHARPTR *pFileName, 
  939.                         FS_u32 *pUnit, FS_u32 *pDirStart) {
  940.   FS_u32 dsize;
  941.   FS_i32 i;
  942.   FS_i32 j;
  943.   FS_FARCHARPTR dname_start;
  944.   FS_FARCHARPTR dname_stop;
  945.   FS_FARCHARPTR chprt;
  946.   int x;
  947.   char dname[12];
  948.   char realname[12];
  950.   /* Find correct unit (unit:name) */
  951.   *pFileName = (FS_FARCHARPTR)FS__CLIB_strchr(pFullName, ':');
  952.   if (*pFileName) {
  953.     /* Scan for unit number */
  954.     *pUnit = FS__CLIB_atoi(pFullName);
  955.     (*pFileName)++;
  956.   }
  957.   else {
  958.     /* Use 1st unit as default */
  959.     *pUnit = 0;
  960.     *pFileName = (FS_FARCHARPTR) pFullName;
  961.   }
  962.   /* Check volume */
  963.   x = !FS__fat_checkunit(Idx, *pUnit);
  964.   if (x) {
  965.     return 0;
  966.   }
  967.   /* Setup pDirStart/dsize for root directory */
  968.   *pDirStart = 0;
  969.   dsize      = FS__fat_dir_size(Idx, *pUnit, 0);
  970.   /* Find correct directory */
  971.   do {
  972.     dname_start = (FS_FARCHARPTR)FS__CLIB_strchr(*pFileName, '\');
  973.     if (dname_start) {
  974.       dname_start++;
  975.       *pFileName = dname_start;
  976.       dname_stop = (FS_FARCHARPTR)FS__CLIB_strchr(dname_start, '\');
  977.     }
  978.     else {
  979.       dname_stop = 0;
  980.     }
  981.     if (dname_stop) {
  982.       i = dname_stop-dname_start;
  983.       if (i >= 12) {
  984.         j = 0;
  985.         for (chprt = dname_start; chprt < dname_stop; chprt++) {
  986.           if (*chprt == '.') {
  987.             i--;
  988.           }
  989.           else if (j < 12) {
  990.             realname[j] = *chprt;
  991.             j++;
  992.           }
  993.         }
  994.         if (i >= 12) {
  995.           return 0;
  996.         }
  997.       }
  998.       else {
  999.         FS__CLIB_strncpy(realname, dname_start, i);
  1000.       }
  1001.       realname[i] = 0;
  1002.       FS__fat_make_realname(dname, realname);
  1003.       *pDirStart =  FS__fat_find_dir(Idx, *pUnit, dname, *pDirStart, dsize);
  1004.       if (*pDirStart) {
  1005.         dsize  =  FS__fat_dir_size(Idx, *pUnit, *pDirStart);
  1006.       }
  1007.       else {
  1008.         dsize = 0;    /* Directory NOT found */
  1009.       }
  1010.     }
  1011.   } while (dname_start);
  1012.   return dsize;
  1013. }
  1016. /*********************************************************************
  1017. *
  1018. *             Global functions section 2
  1019. *
  1020. **********************************************************************
  1022.   These are real global functions, which are used by the API Layer
  1023.   of the file system.
  1024.   
  1025. */
  1027. /*********************************************************************
  1028. *
  1029. *             FS__fat_fopen
  1030. *
  1031.   Description:
  1032.   FS internal function. Open an existing file or create a new one.
  1034.   Parameters:
  1035.   pFileName   - File name. 
  1036.   pMode       - Mode for opening the file.
  1037.   pFile       - Pointer to an FS_FILE data structure.
  1038.   
  1039.   Return value:
  1040.   ==0         - Unable to open the file.
  1041.   !=0         - Address of the FS_FILE data structure.
  1042. */
  1044. FS_FILE *FS__fat_fopen(const char *pFileName, const char *pMode, FS_FILE *pFile) {
  1045.   FS_u32 unit;
  1046.   FS_u32 dstart;
  1047.   FS_u32 dsize;
  1048.   FS_i32 i;
  1049.   FS_FARCHARPTR fname;
  1050.   FS__fat_dentry_type s;
  1051.   char realname[12];
  1052.   int lexp_a;
  1053.   int lexp_b;
  1054.   
  1055.   if (!pFile) {
  1056.     return 0;  /* Not a valid pointer to an FS_FILE structure*/
  1057.   }
  1058.   dsize = FS__fat_findpath(pFile->dev_index, pFileName, &fname, &unit, &dstart);
  1059.   if (dsize == 0) {
  1060.     return 0;  /* Directory not found */
  1061.   }
  1062.   FS__lb_ioctl(FS__pDevInfo[pFile->dev_index].devdriver, unit, FS_CMD_INC_BUSYCNT, 0, (void*)0);  /* Turn on busy signal */
  1063.   FS__fat_make_realname(realname, fname);  /* Convert name to FAT real name */
  1064.   /* FileSize = 0 */
  1065.   s.data[28] = 0x00;      
  1066.   s.data[29] = 0x00;
  1067.   s.data[30] = 0x00;
  1068.   s.data[31] = 0x00;
  1069.   i = _FS_fat_find_file(pFile->dev_index, unit, realname, &s, dstart, dsize);
  1070.   /* Delete file */
  1071.   lexp_b = (FS__CLIB_strcmp(pMode, "del") == 0);    /* Delete file request */
  1072.   lexp_a = lexp_b && (i >= 0);                      /* File does exist */
  1073.   if (lexp_a) {
  1074.     i = FS__fat_DeleteFileOrDir(pFile->dev_index, unit, realname, dstart, dsize, 1);
  1075.     if (i != 0) {
  1076.       pFile->error = -1;
  1077.     }
  1078.     else {
  1079.       pFile->error = 0;
  1080.     }
  1081.     FS__lb_ioctl(FS__pDevInfo[pFile->dev_index].devdriver, pFile->fileid_lo, FS_CMD_FLUSH_CACHE, 2, (void*)0);
  1082.     FS__lb_ioctl(FS__pDevInfo[pFile->dev_index].devdriver, unit, FS_CMD_DEC_BUSYCNT, 0, (void*)0);  /* Turn off busy signal */
  1083.     return 0;
  1084.   }
  1085.   else if (lexp_b) {
  1086.     FS__lb_ioctl(FS__pDevInfo[pFile->dev_index].devdriver, unit, FS_CMD_DEC_BUSYCNT, 0, (void*)0);  /* Turn off busy signal */
  1087.     pFile->error = -1;
  1088.     return 0;
  1089.   }
  1090.   /* Check read only */
  1091.   lexp_a = ((i >= 0) && ((s.data[11] & FS_FAT_ATTR_READ_ONLY) != 0)) &&
  1092.           ((pFile->mode_w) || (pFile->mode_a) || (pFile->mode_c));
  1093.   if (lexp_a) {
  1094.     /* Files is RO and we try to create, write or append */
  1095.     FS__lb_ioctl(FS__pDevInfo[pFile->dev_index].devdriver, unit, FS_CMD_DEC_BUSYCNT, 0, (void*)0);  /* Turn off busy signal */
  1096.     return 0;
  1097.   }
  1098.   lexp_a = ( i>= 0) && (!pFile->mode_a) && (((pFile->mode_w) && (!pFile->mode_r)) || 
  1099.           ((pFile->mode_w) && (pFile->mode_c) && (pFile->mode_r)) );
  1100.   if (lexp_a) {
  1101.     /* Delete old file */
  1102.     i = FS__fat_DeleteFileOrDir(pFile->dev_index, unit, realname, dstart, dsize, 1);
  1103.     /* FileSize = 0 */
  1104.     s.data[28] = 0x00;      
  1105.     s.data[29] = 0x00;
  1106.     s.data[30] = 0x00;
  1107.     s.data[31] = 0x00;
  1108.     i=-1;
  1109.   }
  1110.   if ((!pFile->mode_c) && (i < 0)) {
  1111.     /* File does not exist and we must not create */
  1112.     FS__lb_ioctl(FS__pDevInfo[pFile->dev_index].devdriver, unit, FS_CMD_DEC_BUSYCNT, 0, (void*)0);  /* Turn off busy signal */
  1113.     return 0;
  1114.   }
  1115.   else if ((pFile->mode_c) && (i < 0)) {
  1116.     /* Create new file */
  1117.     i = _FS_fat_create_file(pFile->dev_index, unit, realname, dstart, dsize);
  1118.     if (i < 0) {
  1119.       /* Could not create file */
  1120.       if (i == -2) {
  1121.         /* Directory is full, try to increase */
  1122.         i = _FS_fat_IncDir(pFile->dev_index, unit, dstart, &dsize);
  1123.         if (i > 0) {
  1124.           i = _FS_fat_create_file(pFile->dev_index, unit, realname, dstart, dsize);
  1125.         }
  1126.       }
  1127.       if (i < 0) {
  1128.         FS__lb_ioctl(FS__pDevInfo[pFile->dev_index].devdriver, unit, FS_CMD_DEC_BUSYCNT, 0, (void*)0);  /* Turn off busy signal */
  1129.         return 0;
  1130.       }
  1131.     }
  1132.   }
  1133.   pFile->fileid_lo  = unit;
  1134.   pFile->fileid_hi  = i;
  1135.   pFile->fileid_ex  = dstart;
  1136.   pFile->EOFClust   = -1;
  1137.   pFile->CurClust   = 0;
  1138.   pFile->error      = 0;
  1139.   pFile->size       = (FS_u32)s.data[28];   /* FileSize */
  1140.   pFile->size      += (FS_u32)0x100UL * s.data[29];
  1141.   pFile->size      += (FS_u32)0x10000UL * s.data[30];
  1142.   pFile->size      += (FS_u32)0x1000000UL * s.data[31];
  1143.   if (pFile->mode_a) {
  1144.     pFile->filepos   = pFile->size;
  1145.   }
  1146.   else {
  1147.     pFile->filepos   = 0;
  1148.   }
  1149.   pFile->inuse     = 1;
  1150.   return pFile;
  1151. }