forked from libretro/RetroArch
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathdirectory.c
1175 lines (1026 loc) · 37.9 KB
/
directory.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
directory.c
Reading, writing and manipulation of the directory structure on
a FAT partition
Copyright (c) 2006 Michael "Chishm" Chisholm
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <string.h>
#include <ctype.h>
#include <wchar.h>
#include <wctype.h>
#include <stdlib.h>
#include <stdio.h>
#include "directory.h"
#include "common.h"
#include "partition.h"
#include "file_allocation_table.h"
#include "bit_ops.h"
#include "filetime.h"
/* Directory entry codes */
#define DIR_ENTRY_LAST 0x00
#define DIR_ENTRY_FREE 0xE5
typedef unsigned short ucs2_t;
/* Long file name directory entry */
enum LFN_offset
{
LFN_offset_ordinal = 0x00, /* Position within LFN */
LFN_offset_char0 = 0x01,
LFN_offset_char1 = 0x03,
LFN_offset_char2 = 0x05,
LFN_offset_char3 = 0x07,
LFN_offset_char4 = 0x09,
LFN_offset_flag = 0x0B, /* Should be equal to ATTRIB_LFN */
LFN_offset_reserved1 = 0x0C, /* Always 0x00 */
LFN_offset_checkSum = 0x0D, /* Checksum of short file name (alias) */
LFN_offset_char5 = 0x0E,
LFN_offset_char6 = 0x10,
LFN_offset_char7 = 0x12,
LFN_offset_char8 = 0x14,
LFN_offset_char9 = 0x16,
LFN_offset_char10 = 0x18,
LFN_offset_reserved2 = 0x1A, /* Always 0x0000 */
LFN_offset_char11 = 0x1C,
LFN_offset_char12 = 0x1E
};
static const int LFN_offset_table[13]={0x01,0x03,0x05,0x07,0x09,0x0E,0x10,0x12,0x14,0x16,0x18,0x1C,0x1E};
#define LFN_END 0x40
#define LFN_DEL 0x80
static const char ILLEGAL_ALIAS_CHARACTERS[] = "\\/:;*?\"<>|&+,=[] ";
static const char ILLEGAL_LFN_CHARACTERS[] = "\\/:*?\"<>|";
/*
Returns number of UCS-2 characters needed to encode an LFN
Returns -1 if it is an invalid LFN
*/
#define ABOVE_UCS_RANGE 0xF0
static int _FAT_directory_lfnLength (const char* name)
{
unsigned int i;
int ucsLength;
const char* tempName = name;
size_t nameLength = strnlen(name, NAME_MAX);
/* Make sure the name is short enough to be valid */
if ( nameLength >= NAME_MAX)
return -1;
/* Make sure it doesn't contain any invalid characters */
if (strpbrk (name, ILLEGAL_LFN_CHARACTERS) != NULL)
return -1;
/* Make sure the name doesn't contain any control codes or codes not representable in UCS-2 */
for (i = 0; i < nameLength; i++)
{
unsigned char ch = (unsigned char) name[i];
if (ch < 0x20 || ch >= ABOVE_UCS_RANGE)
return -1;
}
/* Convert to UCS-2 and get the resulting length */
ucsLength = mbsrtowcs(NULL, &tempName, MAX_LFN_LENGTH, NULL);
if (ucsLength < 0 || ucsLength >= MAX_LFN_LENGTH)
return -1;
/* Otherwise it is valid */
return ucsLength;
}
/*
Convert a multibyte encoded string into a NUL-terminated UCS-2 string, storing at most len characters
return number of characters stored
*/
static size_t _FAT_directory_mbstoucs2 (ucs2_t* dst, const char* src, size_t len)
{
mbstate_t ps = {0};
wchar_t tempChar;
int bytes;
size_t count = 0;
while (count < len-1 && *src != '\0')
{
bytes = mbrtowc (&tempChar, src, MB_CUR_MAX, &ps);
if (bytes > 0)
{
*dst = (ucs2_t)tempChar;
src += bytes;
dst++;
count++;
}
else if (bytes == 0)
break;
else
return -1;
}
*dst = '\0';
return count;
}
/*
Convert a UCS-2 string into a NUL-terminated multibyte string, storing at most len chars
return number of chars stored, or (size_t)-1 on error
*/
static size_t _FAT_directory_ucs2tombs (char* dst, const ucs2_t* src, size_t len)
{
mbstate_t ps = {0};
size_t count = 0;
int bytes;
char buff[MB_CUR_MAX];
int i;
while (count < len - 1 && *src != '\0')
{
bytes = wcrtomb (buff, *src, &ps);
if (bytes < 0)
return -1;
if (count + bytes < len && bytes > 0)
{
for (i = 0; i < bytes; i++)
*dst++ = buff[i];
src++;
count += bytes;
}
else
break;
}
*dst = L'\0';
return count;
}
/*
Case-independent comparison of two multibyte encoded strings
*/
static int _FAT_directory_mbsncasecmp (const char* s1, const char* s2, size_t len1)
{
wchar_t wc1, wc2;
mbstate_t ps1 = {0};
mbstate_t ps2 = {0};
size_t b1 = 0;
size_t b2 = 0;
if (len1 == 0)
return 0;
do
{
s1 += b1;
s2 += b2;
b1 = mbrtowc(&wc1, s1, MB_CUR_MAX, &ps1);
b2 = mbrtowc(&wc2, s2, MB_CUR_MAX, &ps2);
if ((int)b1 < 0 || (int)b2 < 0)
break;
len1 -= b1;
} while (len1 > 0 && towlower(wc1) == towlower(wc2) && wc1 != 0);
return towlower(wc1) - towlower(wc2);
}
static bool _FAT_directory_entryGetAlias (const u8* entryData, char* destName)
{
char c;
bool caseInfo;
int i = 0;
int j = 0;
destName[0] = '\0';
if (entryData[0] != DIR_ENTRY_FREE)
{
if (entryData[0] == '.')
{
destName[0] = '.';
if (entryData[1] == '.')
{
destName[1] = '.';
destName[2] = '\0';
}
else
destName[1] = '\0';
}
else
{
/* Copy the filename from the dirEntry to the string */
caseInfo = entryData[DIR_ENTRY_caseInfo] & CASE_LOWER_BASE;
for (i = 0; (i < 8) && (entryData[DIR_ENTRY_name + i] != ' '); i++)
{
c = entryData[DIR_ENTRY_name + i];
destName[i] = (caseInfo ? tolower((unsigned char)c) : c);
}
/* Copy the extension from the dirEntry to the string */
if (entryData[DIR_ENTRY_extension] != ' ')
{
destName[i++] = '.';
caseInfo = entryData[DIR_ENTRY_caseInfo] & CASE_LOWER_EXT;
for ( j = 0; (j < 3) && (entryData[DIR_ENTRY_extension + j] != ' '); j++)
{
c = entryData[DIR_ENTRY_extension + j];
destName[i++] = (caseInfo ? tolower((unsigned char)c) : c);
}
}
destName[i] = '\0';
}
}
return (destName[0] != '\0');
}
uint32_t _FAT_directory_entryGetCluster (PARTITION* partition, const uint8_t* entryData)
{
/* Only use high 16 bits of start cluster when we are certain they are correctly defined */
if (partition->filesysType == FS_FAT32)
return u8array_to_u16(entryData,DIR_ENTRY_cluster) | (u8array_to_u16(entryData, DIR_ENTRY_clusterHigh) << 16);
return u8array_to_u16(entryData,DIR_ENTRY_cluster);
}
static bool _FAT_directory_incrementDirEntryPosition (PARTITION* partition, DIR_ENTRY_POSITION* entryPosition, bool extendDirectory)
{
DIR_ENTRY_POSITION position = *entryPosition;
uint32_t tempCluster;
/* Increment offset, wrapping at the end of a sector */
++ position.offset;
if (position.offset == partition->bytesPerSector / DIR_ENTRY_DATA_SIZE)
{
position.offset = 0;
/* Increment sector when wrapping */
++ position.sector;
/* But wrap at the end of a cluster */
if ((position.sector == partition->sectorsPerCluster) && (position.cluster != FAT16_ROOT_DIR_CLUSTER))
{
position.sector = 0;
/* Move onto the next cluster, making sure there is another cluster to go to */
tempCluster = _FAT_fat_nextCluster(partition, position.cluster);
if (tempCluster == CLUSTER_EOF)
{
if (extendDirectory)
{
tempCluster = _FAT_fat_linkFreeClusterCleared (partition, position.cluster);
if (!_FAT_fat_isValidCluster(partition, tempCluster))
return false; /* This will only happen if the disc is full */
}
else
return false; /* Got to the end of the directory, not extending it */
}
position.cluster = tempCluster;
}
else if ((position.cluster == FAT16_ROOT_DIR_CLUSTER) && (position.sector == (partition->dataStart - partition->rootDirStart)))
return false; /* Got to end of root directory, can't extend it */
}
*entryPosition = position;
return true;
}
bool _FAT_directory_getNextEntry (PARTITION* partition, DIR_ENTRY* entry)
{
DIR_ENTRY_POSITION entryEnd;
uint8_t entryData[0x20];
ucs2_t lfn[MAX_LFN_LENGTH];
bool notFound, found;
int lfnPos;
uint8_t chkSum;
bool lfnExists;
int i;
uint8_t lfnChkSum = 0;
DIR_ENTRY_POSITION entryStart = entry->dataEnd;
/* Make sure we are using the correct root directory, in case of FAT32 */
if (entryStart.cluster == FAT16_ROOT_DIR_CLUSTER)
entryStart.cluster = partition->rootDirCluster;
entryEnd = entryStart;
lfnExists = false;
found = false;
notFound = false;
while (!found && !notFound)
{
if (_FAT_directory_incrementDirEntryPosition (partition, &entryEnd, false) == false)
{
notFound = true;
break;
}
_FAT_cache_readPartialSector (partition->cache, entryData,
_FAT_fat_clusterToSector(partition, entryEnd.cluster) + entryEnd.sector,
entryEnd.offset * DIR_ENTRY_DATA_SIZE, DIR_ENTRY_DATA_SIZE);
if (entryData[DIR_ENTRY_attributes] == ATTRIB_LFN)
{
/* It's an LFN */
if (entryData[LFN_offset_ordinal] & LFN_DEL)
lfnExists = false;
else if (entryData[LFN_offset_ordinal] & LFN_END)
{
/* Last part of LFN, make sure it isn't deleted using previous if(Thanks MoonLight) */
entryStart = entryEnd; /* This is the start of a directory entry */
lfnExists = true;
lfnPos = (entryData[LFN_offset_ordinal] & ~LFN_END) * 13;
if (lfnPos > MAX_LFN_LENGTH - 1)
lfnPos = MAX_LFN_LENGTH - 1;
lfn[lfnPos] = '\0'; /* Set end of lfn to null character */
lfnChkSum = entryData[LFN_offset_checkSum];
}
if (lfnChkSum != entryData[LFN_offset_checkSum])
lfnExists = false;
if (lfnExists)
{
lfnPos = ((entryData[LFN_offset_ordinal] & ~LFN_END) - 1) * 13;
for (i = 0; i < 13; i++)
{
if (lfnPos + i < MAX_LFN_LENGTH - 1)
lfn[lfnPos + i] = entryData[LFN_offset_table[i]] | (entryData[LFN_offset_table[i]+1] << 8);
}
}
}
/* This is a volume name, don't bother with it */
else if (entryData[DIR_ENTRY_attributes] & ATTRIB_VOL) { }
else if (entryData[0] == DIR_ENTRY_LAST)
notFound = true;
else if ((entryData[0] != DIR_ENTRY_FREE) && (entryData[0] > 0x20) && !(entryData[DIR_ENTRY_attributes] & ATTRIB_VOL))
{
if (lfnExists)
{
/* Calculate file checksum */
chkSum = 0;
/* NOTE: The operation is an unsigned char rotate right */
for (i=0; i < 11; i++)
chkSum = ((chkSum & 1) ? 0x80 : 0) + (chkSum >> 1) + entryData[i];
if (chkSum != lfnChkSum)
{
lfnExists = false;
entry->filename[0] = '\0';
}
}
if (lfnExists)
{
/* Failed to convert the file name to UTF-8. Maybe the wrong locale is set? */
if (_FAT_directory_ucs2tombs (entry->filename, lfn, NAME_MAX) == (size_t)-1)
return false;
}
else
{
entryStart = entryEnd;
_FAT_directory_entryGetAlias (entryData, entry->filename);
}
found = true;
}
}
/* If no file is found, return false */
if (notFound)
return false;
/* Fill in the directory entry struct */
entry->dataStart = entryStart;
entry->dataEnd = entryEnd;
memcpy (entry->entryData, entryData, DIR_ENTRY_DATA_SIZE);
return true;
}
bool _FAT_directory_getFirstEntry (PARTITION* partition, DIR_ENTRY* entry, uint32_t dirCluster)
{
entry->dataStart.cluster = dirCluster;
entry->dataStart.sector = 0;
entry->dataStart.offset = -1; /* Start before the beginning of the directory */
entry->dataEnd = entry->dataStart;
return _FAT_directory_getNextEntry (partition, entry);
}
bool _FAT_directory_getRootEntry (PARTITION* partition, DIR_ENTRY* entry)
{
entry->dataStart.cluster = 0;
entry->dataStart.sector = 0;
entry->dataStart.offset = 0;
entry->dataEnd = entry->dataStart;
memset (entry->filename, '\0', NAME_MAX);
entry->filename[0] = '.';
memset (entry->entryData, 0, DIR_ENTRY_DATA_SIZE);
memset (entry->entryData, ' ', 11);
entry->entryData[0] = '.';
entry->entryData[DIR_ENTRY_attributes] = ATTRIB_DIR;
u16_to_u8array (entry->entryData, DIR_ENTRY_cluster, partition->rootDirCluster);
u16_to_u8array (entry->entryData, DIR_ENTRY_clusterHigh, partition->rootDirCluster >> 16);
return true;
}
bool _FAT_directory_getVolumeLabel (PARTITION* partition, char *label)
{
DIR_ENTRY entry;
DIR_ENTRY_POSITION entryEnd;
uint8_t entryData[DIR_ENTRY_DATA_SIZE];
int i;
bool end;
_FAT_directory_getRootEntry(partition, &entry);
entryEnd = entry.dataEnd;
/* Make sure we are using the correct root directory, in case of FAT32 */
if (entryEnd.cluster == FAT16_ROOT_DIR_CLUSTER)
entryEnd.cluster = partition->rootDirCluster;
label[0]='\0';
label[11]='\0';
end = false;
/* this entry should be among the first 3 entries in the root directory table,
* if not, then system can have trouble displaying the right volume label */
while(!end)
{
/* error reading */
if(!_FAT_cache_readPartialSector (partition->cache, entryData,
_FAT_fat_clusterToSector(partition, entryEnd.cluster) + entryEnd.sector,
entryEnd.offset * DIR_ENTRY_DATA_SIZE, DIR_ENTRY_DATA_SIZE))
return false;
if (entryData[DIR_ENTRY_attributes] == ATTRIB_VOL && entryData[0] != DIR_ENTRY_FREE)
{
for (i = 0; i < 11; i++)
label[i] = entryData[DIR_ENTRY_name + i];
return true;
}
else if (entryData[0] == DIR_ENTRY_LAST)
end = true;
if (_FAT_directory_incrementDirEntryPosition (partition, &entryEnd, false) == false)
end = true;
}
return false;
}
bool _FAT_directory_entryFromPosition (PARTITION* partition, DIR_ENTRY* entry)
{
DIR_ENTRY_POSITION entryStart = entry->dataStart;
DIR_ENTRY_POSITION entryEnd = entry->dataEnd;
bool entryStillValid;
bool finished;
ucs2_t lfn[MAX_LFN_LENGTH];
int i;
int lfnPos;
uint8_t entryData[DIR_ENTRY_DATA_SIZE];
memset (entry->filename, '\0', NAME_MAX);
/* Create an empty directory entry to overwrite the old ones with */
for ( entryStillValid = true, finished = false;
entryStillValid && !finished;
entryStillValid = _FAT_directory_incrementDirEntryPosition (partition, &entryStart, false))
{
_FAT_cache_readPartialSector (partition->cache, entryData,
_FAT_fat_clusterToSector(partition, entryStart.cluster) + entryStart.sector,
entryStart.offset * DIR_ENTRY_DATA_SIZE, DIR_ENTRY_DATA_SIZE);
if ((entryStart.cluster == entryEnd.cluster)
&& (entryStart.sector == entryEnd.sector)
&& (entryStart.offset == entryEnd.offset))
{
/* Copy the entry data and stop, since this is the
* last section of the directory entry */
memcpy (entry->entryData, entryData, DIR_ENTRY_DATA_SIZE);
finished = true;
}
else
{
/* Copy the long file name data */
lfnPos = ((entryData[LFN_offset_ordinal] & ~LFN_END) - 1) * 13;
for (i = 0; i < 13; i++)
{
if (lfnPos + i < MAX_LFN_LENGTH - 1)
lfn[lfnPos + i] = entryData[LFN_offset_table[i]] | (entryData[LFN_offset_table[i]+1] << 8);
}
}
}
if (!entryStillValid)
return false;
entryStart = entry->dataStart;
if ((entryStart.cluster == entryEnd.cluster)
&& (entryStart.sector == entryEnd.sector)
&& (entryStart.offset == entryEnd.offset))
{
/* Since the entry doesn't have a long file name, extract the short filename */
if (!_FAT_directory_entryGetAlias (entry->entryData, entry->filename))
return false;
}
else
{
/* Encode the long file name into a multibyte string */
if (_FAT_directory_ucs2tombs (entry->filename, lfn, NAME_MAX) == (size_t)-1)
return false;
}
return true;
}
bool _FAT_directory_entryFromPath (PARTITION* partition, DIR_ENTRY* entry, const char* path, const char* pathEnd)
{
size_t dirnameLength;
const char* nextPathPosition;
uint32_t dirCluster;
bool foundFile;
char alias[MAX_ALIAS_LENGTH];
const char *pathPosition = path;
bool found = false;
bool notFound = false;
/* Set pathEnd to the end of the path string */
if (pathEnd == NULL)
pathEnd = strchr (path, '\0');
if (pathPosition[0] == DIR_SEPARATOR)
{
/* Start at root directory */
dirCluster = partition->rootDirCluster;
/* Consume separator(s) */
while (pathPosition[0] == DIR_SEPARATOR)
pathPosition++;
/* If the path is only specifying a directory in the form of "/" return it */
if (pathPosition >= pathEnd)
{
_FAT_directory_getRootEntry (partition, entry);
found = true;
}
}
/* Start in current working directory */
else
dirCluster = partition->cwdCluster;
while (!found && !notFound)
{
/* Get the name of the next required subdirectory within the path */
nextPathPosition = strchr (pathPosition, DIR_SEPARATOR);
if (nextPathPosition != NULL)
dirnameLength = nextPathPosition - pathPosition;
else
dirnameLength = strlen(pathPosition);
/* The path is too long to bother with */
if (dirnameLength > NAME_MAX)
return false;
/* Check for "." or ".." when the dirCluster is root cluster
* These entries do not exist, so we must fake it */
if ((dirCluster == partition->rootDirCluster)
&& ((strncmp(".", pathPosition, dirnameLength) == 0)
|| (strncmp("..", pathPosition, dirnameLength) == 0)))
{
foundFile = true;
_FAT_directory_getRootEntry(partition, entry);
}
else
{
/* Look for the directory within the path */
foundFile = _FAT_directory_getFirstEntry (partition, entry, dirCluster);
while (foundFile && !found && !notFound)
{
/* It hasn't already found the file
* Check if the filename matches */
if ((dirnameLength == strnlen(entry->filename, NAME_MAX))
&& (_FAT_directory_mbsncasecmp(pathPosition, entry->filename, dirnameLength) == 0))
found = true;
/* Check if the alias matches */
_FAT_directory_entryGetAlias (entry->entryData, alias);
if ((dirnameLength == strnlen(alias, MAX_ALIAS_LENGTH))
&& (strncasecmp(pathPosition, alias, dirnameLength) == 0))
found = true;
/* Make sure that we aren't trying to follow a file instead of a directory in the path */
if (found && !(entry->entryData[DIR_ENTRY_attributes] & ATTRIB_DIR) && (nextPathPosition != NULL))
found = false;
if (!found)
foundFile = _FAT_directory_getNextEntry (partition, entry);
}
}
if (!foundFile)
{
/* Check that the search didn't get to the end of the directory */
notFound = true;
found = false;
}
/* Check that we reached the end of the path */
else if ((nextPathPosition == NULL) || (nextPathPosition >= pathEnd))
found = true;
else if (entry->entryData[DIR_ENTRY_attributes] & ATTRIB_DIR)
{
dirCluster = _FAT_directory_entryGetCluster (partition, entry->entryData);
if (dirCluster == CLUSTER_ROOT)
dirCluster = partition->rootDirCluster;
pathPosition = nextPathPosition;
/* Consume separator(s) */
while (pathPosition[0] == DIR_SEPARATOR)
pathPosition++;
/* The requested directory was found */
if (pathPosition >= pathEnd)
found = true;
else
found = false;
}
}
if (found && !notFound)
{
/* On FAT32 it should specify an actual cluster for the root entry,
* not cluster 0 as on FAT16 */
if (partition->filesysType == FS_FAT32 && (entry->entryData[DIR_ENTRY_attributes] & ATTRIB_DIR) &&
_FAT_directory_entryGetCluster (partition, entry->entryData) == CLUSTER_ROOT)
_FAT_directory_getRootEntry (partition, entry);
return true;
}
return false;
}
bool _FAT_directory_removeEntry (PARTITION* partition, DIR_ENTRY* entry)
{
DIR_ENTRY_POSITION entryStart = entry->dataStart;
DIR_ENTRY_POSITION entryEnd = entry->dataEnd;
bool entryStillValid;
bool finished;
uint8_t entryData[DIR_ENTRY_DATA_SIZE];
/* Create an empty directory entry to overwrite the old ones with */
for ( entryStillValid = true, finished = false;
entryStillValid && !finished;
entryStillValid = _FAT_directory_incrementDirEntryPosition (partition, &entryStart, false))
{
_FAT_cache_readPartialSector (partition->cache, entryData, _FAT_fat_clusterToSector(partition, entryStart.cluster) + entryStart.sector, entryStart.offset * DIR_ENTRY_DATA_SIZE, DIR_ENTRY_DATA_SIZE);
entryData[0] = DIR_ENTRY_FREE;
_FAT_cache_writePartialSector (partition->cache, entryData, _FAT_fat_clusterToSector(partition, entryStart.cluster) + entryStart.sector, entryStart.offset * DIR_ENTRY_DATA_SIZE, DIR_ENTRY_DATA_SIZE);
if ((entryStart.cluster == entryEnd.cluster) && (entryStart.sector == entryEnd.sector) && (entryStart.offset == entryEnd.offset))
finished = true;
}
if (!entryStillValid)
return false;
return true;
}
static bool _FAT_directory_findEntryGap (PARTITION* partition, DIR_ENTRY* entry, uint32_t dirCluster, size_t size)
{
DIR_ENTRY_POSITION gapStart;
DIR_ENTRY_POSITION gapEnd;
uint8_t entryData[DIR_ENTRY_DATA_SIZE];
size_t dirEntryRemain;
bool endOfDirectory, entryStillValid;
/* Scan Dir for free entry */
gapEnd.offset = 0;
gapEnd.sector = 0;
gapEnd.cluster = dirCluster;
gapStart = gapEnd;
entryStillValid = true;
dirEntryRemain = size;
endOfDirectory = false;
while (entryStillValid && !endOfDirectory && (dirEntryRemain > 0))
{
_FAT_cache_readPartialSector (partition->cache, entryData,
_FAT_fat_clusterToSector(partition, gapEnd.cluster) + gapEnd.sector,
gapEnd.offset * DIR_ENTRY_DATA_SIZE, DIR_ENTRY_DATA_SIZE);
if (entryData[0] == DIR_ENTRY_LAST)
{
if (dirEntryRemain == size)
gapStart = gapEnd;
-- dirEntryRemain;
endOfDirectory = true;
}
else if (entryData[0] == DIR_ENTRY_FREE)
{
if (dirEntryRemain == size)
gapStart = gapEnd;
-- dirEntryRemain;
}
else
dirEntryRemain = size;
if (!endOfDirectory && (dirEntryRemain > 0))
entryStillValid = _FAT_directory_incrementDirEntryPosition (partition, &gapEnd, true);
}
/* Make sure the scanning didn't fail */
if (!entryStillValid)
return false;
/* Save the start entry, since we know it is valid */
entry->dataStart = gapStart;
if (endOfDirectory)
{
memset (entryData, DIR_ENTRY_LAST, DIR_ENTRY_DATA_SIZE);
dirEntryRemain += 1; /* Increase by one to take account of End Of Directory Marker */
while ((dirEntryRemain > 0) && entryStillValid)
{
/* Get the gapEnd before incrementing it, so the second to last one is saved */
entry->dataEnd = gapEnd;
/* Increment gapEnd, moving onto the next entry */
entryStillValid = _FAT_directory_incrementDirEntryPosition (partition, &gapEnd, true);
-- dirEntryRemain;
/* Fill the entry with blanks */
_FAT_cache_writePartialSector (partition->cache, entryData,
_FAT_fat_clusterToSector(partition, gapEnd.cluster) + gapEnd.sector,
gapEnd.offset * DIR_ENTRY_DATA_SIZE, DIR_ENTRY_DATA_SIZE);
}
if (!entryStillValid)
return false;
}
else
entry->dataEnd = gapEnd;
return true;
}
static bool _FAT_directory_entryExists (PARTITION* partition, const char* name, uint32_t dirCluster)
{
DIR_ENTRY tempEntry;
bool foundFile;
char alias[MAX_ALIAS_LENGTH];
size_t dirnameLength = strnlen(name, NAME_MAX);
if (dirnameLength >= NAME_MAX)
return false;
/* Make sure the entry doesn't already exist */
foundFile = _FAT_directory_getFirstEntry (partition, &tempEntry, dirCluster);
while (foundFile)
{
/* It hasn't already found the file
* Check if the filename matches */
if ((dirnameLength == strnlen(tempEntry.filename, NAME_MAX))
&& (_FAT_directory_mbsncasecmp(name, tempEntry.filename, dirnameLength) == 0))
return true;
/* Check if the alias matches */
_FAT_directory_entryGetAlias (tempEntry.entryData, alias);
if ((strncasecmp(name, alias, MAX_ALIAS_LENGTH) == 0))
return true;
foundFile = _FAT_directory_getNextEntry (partition, &tempEntry);
}
return false;
}
/*
Creates an alias for a long file name. If the alias is not an exact match for the
filename, it returns the number of characters in the alias. If the two names match,
it returns 0. If there was an error, it returns -1.
*/
static int _FAT_directory_createAlias (char* alias, const char* lfn)
{
bool lossyConversion = false; /* Set when the alias had to be modified to be valid */
int lfnPos = 0;
int aliasPos = 0;
wchar_t lfnChar;
int oemChar;
mbstate_t ps = {0};
int bytesUsed = 0;
const char* lfnExt;
int aliasExtLen;
/* Strip leading periods */
while (lfn[lfnPos] == '.')
{
lfnPos ++;
lossyConversion = true;
}
/* Primary portion of alias */
while (aliasPos < 8 && lfn[lfnPos] != '.' && lfn[lfnPos] != '\0')
{
bytesUsed = mbrtowc(&lfnChar, lfn + lfnPos, NAME_MAX - lfnPos, &ps);
if (bytesUsed < 0)
return -1;
oemChar = wctob(towupper((wint_t)lfnChar));
/* Case of letter was changed */
if (wctob((wint_t)lfnChar) != oemChar)
lossyConversion = true;
if (oemChar == ' ')
{
/* Skip spaces in filename */
lossyConversion = true;
lfnPos += bytesUsed;
continue;
}
if (oemChar == EOF)
{
oemChar = '_'; /* Replace unconvertable characters with underscores */
lossyConversion = true;
}
if (strchr (ILLEGAL_ALIAS_CHARACTERS, oemChar) != NULL)
{
/* Invalid Alias character */
oemChar = '_'; /* Replace illegal characters with underscores */
lossyConversion = true;
}
alias[aliasPos] = (char)oemChar;
aliasPos++;
lfnPos += bytesUsed;
}
/* Name was more than 8 characters long */
if (lfn[lfnPos] != '.' && lfn[lfnPos] != '\0')
lossyConversion = true;
/* Alias extension */
lfnExt = strrchr (lfn, '.');
/* More than one period in name */
if (lfnExt != NULL && lfnExt != strchr (lfn, '.'))
lossyConversion = true;
if (lfnExt != NULL && lfnExt[1] != '\0')
{
lfnExt++;
alias[aliasPos] = '.';
aliasPos++;
memset (&ps, 0, sizeof(ps));
for (aliasExtLen = 0; aliasExtLen < MAX_ALIAS_EXT_LENGTH && *lfnExt != '\0'; aliasExtLen++)
{
bytesUsed = mbrtowc(&lfnChar, lfnExt, NAME_MAX - lfnPos, &ps);
if (bytesUsed < 0)
return -1;
oemChar = wctob(towupper((wint_t)lfnChar));
/* Case of letter was changed */
if (wctob((wint_t)lfnChar) != oemChar)
lossyConversion = true;
if (oemChar == ' ')
{
/* Skip spaces in alias */
lossyConversion = true;
lfnExt += bytesUsed;
continue;
}
if (oemChar == EOF)
{
oemChar = '_'; /* Replace unconvertable characters with underscores */
lossyConversion = true;
}
if (strchr (ILLEGAL_ALIAS_CHARACTERS, oemChar) != NULL)
{
/* Invalid Alias character */
oemChar = '_'; /* Replace illegal characters with underscores */
lossyConversion = true;
}
alias[aliasPos] = (char)oemChar;
aliasPos++;
lfnExt += bytesUsed;
}
/* Extension was more than 3 characters long */
if (*lfnExt != '\0')
lossyConversion = true;
}
alias[aliasPos] = '\0';
if (lossyConversion)
return aliasPos;
return 0;
}
bool _FAT_directory_addEntry (PARTITION* partition, DIR_ENTRY* entry, uint32_t dirCluster)
{
size_t entrySize;
uint8_t lfnEntry[DIR_ENTRY_DATA_SIZE];
int i,j; /* Must be signed for use when decrementing in for loop */
char *tmpCharPtr;
DIR_ENTRY_POSITION curEntryPos;
bool entryStillValid;
uint8_t aliasCheckSum = 0;
char alias [MAX_ALIAS_LENGTH];
int aliasLen;
int lfnLen;
/* Remove trailing spaces */
for (i = strlen (entry->filename) - 1; (i >= 0) && (entry->filename[i] == ' '); --i)
entry->filename[i] = '\0';
#if 0
/* Remove leading spaces */
for (i = 0; entry->filename[i] == ' '; ++i) ;
if (i > 0)
memmove (entry->filename, entry->filename + i, strlen (entry->filename + i));
#endif
/* Make sure the filename is not 0 length */
if (strnlen (entry->filename, NAME_MAX) < 1)
return false;
/* Make sure the filename is at least a valid LFN */
lfnLen = _FAT_directory_lfnLength (entry->filename);
if (lfnLen < 0)
return false;
/* Remove junk in filename */
i = strlen (entry->filename);
memset (entry->filename + i, '\0', NAME_MAX - i);
/* Make sure the entry doesn't already exist */
if (_FAT_directory_entryExists (partition, entry->filename, dirCluster))
return false;
/* Clear out alias, so we can generate a new one */
memset (entry->entryData, ' ', 11);
if ( strncmp(entry->filename, ".", NAME_MAX) == 0)
{
/* "." entry */
entry->entryData[0] = '.';
entrySize = 1;
}
else if ( strncmp(entry->filename, "..", NAME_MAX) == 0)
{
/* ".." entry */
entry->entryData[0] = '.';
entry->entryData[1] = '.';
entrySize = 1;
}
else
{
/* Normal file name */
aliasLen = _FAT_directory_createAlias (alias, entry->filename);
if (aliasLen < 0)