Changeset 34fdb75 in mainline

Timestamp:

2011-06-10T16:55:14Z (13 years ago)

Author:

Oleg Romanenko <romanenko.oleg@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

65ccd23

Parents:

ed19497

Message:

Macros and functions for managing Long Entry and extracting long name

Location:

uspace/srv/fs/fat

Files:

• fat_dentry.c (modified) (3 diffs)
• fat_dentry.h (modified) (5 diffs)

uspace/srv/fs/fat/fat_dentry.c

@@ -39 +39 @@
 #include <ctype.h>
 #include <str.h>
+#include <errno.h>
 
 static bool is_d_char(const char ch)
@@ -218 +219 @@
 fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *d)
 {
+/*      if (d->attr == FAT_ATTR_LFN) { */
+                /* long name entry */
+/*              if (d->attr & FAT_LFN_ERASED)
+                        return FAT_DENTRY_FREE;
+                else
+                        return FAT_DENTRY_LFN;
+        }*/
         if (d->attr & FAT_ATTR_VOLLABEL) {
                 /* volume label entry */
@@ -259 +267 @@
 }
 
+/** Get number of bytes in a string with size limit.
+ *
+ * @param str  NULL-terminated (or not) string.
+ * @param size Maximum number of bytes to consider.
+ *
+ * @return Number of bytes in string (without 0 and ff).
+ *
+ */
+size_t fat_lfn_str_nlength(const uint8_t *str, size_t size)
+{
+        size_t offset = 0;
+
+        while (offset < size) {
+                if ((str[offset] == 0x00 && str[offset+1] == 0x00) ||
+                        (str[offset] == 0xff && str[offset+1] == 0xff)) 
+                        break;
+                
+                offset += 2;
+        }
+        return offset;
+}
+
+/** Get number of bytes in a FAT long entry occuped by characters.
+ *
+ * @param d FAT long entry.
+ *
+ * @return Number of bytes.
+ *
+ */
+size_t fat_lfn_size(const fat_dentry_t *d)
+{
+        size_t size = 0;
+        
+        size += fat_lfn_str_nlength(FAT_LFN_PART1(d), FAT_LFN_PART1_SIZE);
+        size += fat_lfn_str_nlength(FAT_LFN_PART2(d), FAT_LFN_PART2_SIZE);
+        size += fat_lfn_str_nlength(FAT_LFN_PART3(d), FAT_LFN_PART3_SIZE);      
+        
+        return size;
+}
+
+void fat_lfn_copy_part(const uint8_t *src, size_t src_size, uint8_t *dst, size_t *offset)
+{
+        int i;
+        for (i=src_size-1; i>0 && (*offset)>1; i-=2) {
+                if ((src[i] == 0x00 && src[i-1] == 0x00) ||
+                        (src[i] == 0xff && src[i-1] == 0xff))
+                        continue;
+                dst[(*offset)-1] = src[i];
+                dst[(*offset)-2] = src[i-1];
+                (*offset)-=2;
+        }
+}
+
+void fat_lfn_copy_entry(const fat_dentry_t *d, uint8_t *dst, size_t *offset)
+{
+        fat_lfn_copy_part(FAT_LFN_PART3(d), FAT_LFN_PART3_SIZE, dst, offset);
+        fat_lfn_copy_part(FAT_LFN_PART2(d), FAT_LFN_PART2_SIZE, dst, offset);
+        fat_lfn_copy_part(FAT_LFN_PART1(d), FAT_LFN_PART1_SIZE, dst, offset);
+}
+
+int fat_lfn_convert_name(const uint8_t *src, size_t src_size, uint8_t *dst, size_t dst_size)
+{
+        size_t i, offset = 0;
+        uint16_t c;
+        int rc;
+        for (i=0; i<src_size; i+=2) {
+                if (src[i+1] == 0x00) {
+                        if (offset+1 < dst_size)
+                                dst[offset++] = src[i];
+                        else
+                                return EOVERFLOW;
+                } else {
+                        c = (src[i] << 8) | src[i+1];
+                        rc = chr_encode(c, (char*)dst, &offset, dst_size);
+                        if (rc!=EOK) {
+                                return rc;
+                        }
+                }
+        }
+        dst[offset] = 0;        
+        return EOK;
+}
+
 
 /**

uspace/srv/fs/fat/fat_dentry.h

@@ -50 +50 @@
 #define FAT_ATTR_SUBDIR   0x10
 #define FAT_ATTR_ARCHIVE  0x20
-#define FAT_ATTR_LNAME \
+#define FAT_ATTR_LFN \
     (FAT_ATTR_RDONLY | FAT_ATTR_HIDDEN | FAT_ATTR_SYSTEM | FAT_ATTR_VOLLABEL)
     
@@ -62 +62 @@
 #define FAT_DENTRY_DOT          0x2e
 #define FAT_DENTRY_ERASED       0xe5
-#define FAT_LAST_LONG_ENTRY 0x40
+#define FAT_LFN_LAST            0x40
+#define FAT_LFN_ERASED          0x80
+
+#define FAT_LFN_ORDER(d) (d->lfn.order)
+#define FAT_IS_LFN(d) \
+    ((FAT_LFN_ORDER(d) & FAT_LFN_LAST) == FAT_LFN_LAST)
+#define FAT_LFN_COUNT(d) \
+    (FAT_LFN_ORDER(d) ^ FAT_LFN_LAST)
+#define FAT_LFN_PART1(d) (d->lfn.part1)
+#define FAT_LFN_PART2(d) (d->lfn.part2)
+#define FAT_LFN_PART3(d) (d->lfn.part3)
+#define FAT_LFN_ATTR(d) (d->lfn.attr)
+#define FAT_LFN_CHKSUM(d) (d->lfn.check_sum)
+
+#define FAT_LFN_NAME_SIZE   255
+#define FAT_LFN_MAX_COUNT   20
+#define FAT_LFN_PART1_SIZE  10
+#define FAT_LFN_PART2_SIZE  12
+#define FAT_LFN_PART3_SIZE  4
+#define FAT_LFN_ENTRY_SIZE \
+    (FAT_LFN_PART1_SIZE + FAT_LFN_PART2_SIZE + FAT_LFN_PART3_SIZE)
 
 typedef enum {
@@ -69 +89 @@
         FAT_DENTRY_FREE,
         FAT_DENTRY_VALID
+        /* FAT_DENTRY_LFN */
 } fat_dentry_clsf_t;
 
@@ -96 +117 @@
                 struct {
                         uint8_t         order;
-                        uint8_t         name1[10];
+                        uint8_t         part1[FAT_LFN_PART1_SIZE];
                         uint8_t         attr;
                         uint8_t         type;
                         uint8_t         check_sum;
-                        uint8_t         name2[12];
+                        uint8_t         part2[FAT_LFN_PART2_SIZE];
                         uint16_t        firstc_lo; /* MUST be 0 */
-                        uint8_t         name3[4];
-                } long_entry __attribute__ ((packed));
+                        uint8_t         part3[FAT_LFN_PART3_SIZE];
+                } lfn __attribute__ ((packed));
         };
 } __attribute__ ((packed)) fat_dentry_t;
+
 
 extern int fat_dentry_namecmp(char *, const char *);
@@ -114 +136 @@
 extern uint8_t fat_dentry_chksum(uint8_t *);
 
+extern size_t fat_lfn_str_nlength(const uint8_t *, size_t);
+extern size_t fat_lfn_size(const fat_dentry_t *);
+extern void fat_lfn_copy_part(const uint8_t *, size_t, uint8_t *, size_t *);
+extern void fat_lfn_copy_entry(const fat_dentry_t *, uint8_t *, size_t *);
+extern int fat_lfn_convert_name(const uint8_t *, size_t, uint8_t *, size_t);
+
+
 #endif