source: mainline/uspace/srv/fs/fat/fat_dentry.c@ 7234617

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 7234617 was 7234617, checked in by Oleg Romanenko <romanenko.oleg@…>, 14 years ago

FAT: fixes for mips support
  • Property mode set to 100644
File size: 8.9 KB
Line 
1/*
2 * Copyright (c) 2008 Jakub Jermar
3 * Copyright (c) 2011 Oleg Romanenko
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/** @addtogroup fs
31 * @{
32 */
33
34/**
35 * @file fat_dentry.c
36 * @brief Functions that work with FAT directory entries.
37 */
38
39#include "fat_dentry.h"
40#include <ctype.h>
41#include <str.h>
42#include <errno.h>
43#include <byteorder.h>
44#include <assert.h>
45
46/** Compare path component with the name read from the dentry.
47 *
48 * This function compares the path component with the name read from the dentry.
49 * The comparison is case insensitive and tolerates a mismatch on the trailing
50 * dot character at the end of the name (i.e. when there is a dot, but no
51 * extension).
52 *
53 * @param name Node name read from the dentry.
54 * @param component Path component.
55 *
56 * @return Zero on match, non-zero otherwise.
57 */
58int fat_dentry_namecmp(char *name, const char *component)
59{
60 int rc;
61 size_t size;
62
63 if (!(rc = stricmp(name, component)))
64 return rc;
65 if (!str_chr(name, '.')) {
66 /*
67 * There is no '.' in the name, so we know that there is enough
68 * space for appending an extra '.' to name.
69 */
70 size = str_size(name);
71 name[size] = '.';
72 name[size + 1] = '\0';
73 rc = stricmp(name, component);
74 }
75 return rc;
76}
77
78void fat_dentry_name_get(const fat_dentry_t *d, char *buf)
79{
80 unsigned int i;
81
82 for (i = 0; i < FAT_NAME_LEN; i++) {
83 if (d->name[i] == FAT_PAD)
84 break;
85
86 if (d->name[i] == FAT_DENTRY_E5_ESC)
87 *buf++ = 0xe5;
88 else {
89 if (d->lcase & FAT_LCASE_LOWER_NAME)
90 *buf++ = tolower(d->name[i]);
91 else
92 *buf++ = d->name[i];
93 }
94 }
95
96 if (d->ext[0] != FAT_PAD)
97 *buf++ = '.';
98
99 for (i = 0; i < FAT_EXT_LEN; i++) {
100 if (d->ext[i] == FAT_PAD) {
101 *buf = '\0';
102 return;
103 }
104
105 if (d->ext[i] == FAT_DENTRY_E5_ESC)
106 *buf++ = 0xe5;
107 else {
108 if (d->lcase & FAT_LCASE_LOWER_EXT)
109 *buf++ = tolower(d->ext[i]);
110 else
111 *buf++ = d->ext[i];
112 }
113 }
114
115 *buf = '\0';
116}
117
118void fat_dentry_name_set(fat_dentry_t *d, const char *name)
119{
120 unsigned int i;
121 const char fake_ext[] = " ";
122 bool lower_name = true;
123 bool lower_ext = true;
124
125 for (i = 0; i < FAT_NAME_LEN; i++) {
126 switch ((uint8_t) *name) {
127 case 0xe5:
128 d->name[i] = FAT_DENTRY_E5_ESC;
129 name++;
130 break;
131 case '\0':
132 case '.':
133 d->name[i] = FAT_PAD;
134 break;
135 default:
136 if (isalpha(*name)) {
137 if (!islower(*name))
138 lower_name = false;
139 }
140
141 d->name[i] = toupper(*name++);
142 break;
143 }
144 }
145
146 if (*name++ != '.')
147 name = fake_ext;
148
149 for (i = 0; i < FAT_EXT_LEN; i++) {
150 switch ((uint8_t) *name) {
151 case 0xe5:
152 d->ext[i] = FAT_DENTRY_E5_ESC;
153 name++;
154 break;
155 case '\0':
156 d->ext[i] = FAT_PAD;
157 break;
158 default:
159 if (isalpha(*name)) {
160 if (!islower(*name))
161 lower_ext = false;
162 }
163
164 d->ext[i] = toupper(*name++);
165 break;
166 }
167 }
168
169 if (lower_name)
170 d->lcase |= FAT_LCASE_LOWER_NAME;
171 else
172 d->lcase &= ~FAT_LCASE_LOWER_NAME;
173
174 if (lower_ext)
175 d->lcase |= FAT_LCASE_LOWER_EXT;
176 else
177 d->lcase &= ~FAT_LCASE_LOWER_EXT;
178}
179
180fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *d)
181{
182 if (d->attr == FAT_ATTR_LFN) {
183 /* long name entry */
184 if (FAT_LFN_ORDER(d) & FAT_LFN_ERASED)
185 return FAT_DENTRY_FREE;
186 else
187 return FAT_DENTRY_LFN;
188 }
189 if (d->attr & FAT_ATTR_VOLLABEL) {
190 /* volume label entry */
191 return FAT_DENTRY_SKIP;
192 }
193 if (d->name[0] == FAT_DENTRY_ERASED) {
194 /* not-currently-used entry */
195 return FAT_DENTRY_FREE;
196 }
197 if (d->name[0] == FAT_DENTRY_UNUSED) {
198 /* never used entry */
199 return FAT_DENTRY_LAST;
200 }
201 if (d->name[0] == FAT_DENTRY_DOT) {
202 /*
203 * Most likely '.' or '..'.
204 * It cannot occur in a regular file name.
205 */
206 return FAT_DENTRY_SKIP;
207 }
208 return FAT_DENTRY_VALID;
209}
210
211/** Compute checksum of Node name.
212 *
213 * Returns an unsigned byte checksum computed on an unsigned byte
214 * array. The array must be 11 bytes long and is assumed to contain
215 * a name stored in the format of a MS-DOS directory entry.
216 *
217 * @param name Node name read from the dentry.
218 *
219 * @return An 8-bit unsigned checksum of the name.
220 */
221uint8_t fat_dentry_chksum(uint8_t *name)
222{
223 uint8_t i, sum=0;
224 for (i=0; i<(FAT_NAME_LEN+FAT_EXT_LEN); i++) {
225 sum = ((sum & 1) ? 0x80 : 0) + (sum >> 1) + name[i];
226 }
227 return sum;
228}
229
230/** Get number of bytes in a string with size limit.
231 *
232 * @param str NULL-terminated (or not) string.
233 * @param size Maximum number of bytes to consider.
234 *
235 * @return Number of bytes in string (without 0 and ff).
236 *
237 */
238size_t fat_lfn_str_nlength(const uint16_t *str, size_t size)
239{
240 size_t offset = 0;
241
242 while (offset < size) {
243 if (str[offset] == 0 || str[offset] == FAT_LFN_PAD)
244 break;
245 offset++;
246 }
247 return offset;
248}
249
250/** Get number of bytes in a FAT long entry occuped by characters.
251 *
252 * @param d FAT long entry.
253 *
254 * @return Number of bytes.
255 *
256 */
257size_t fat_lfn_size(const fat_dentry_t *d)
258{
259 size_t size = 0;
260
261 size += fat_lfn_str_nlength(FAT_LFN_PART1(d), FAT_LFN_PART1_SIZE);
262 size += fat_lfn_str_nlength(FAT_LFN_PART2(d), FAT_LFN_PART2_SIZE);
263 size += fat_lfn_str_nlength(FAT_LFN_PART3(d), FAT_LFN_PART3_SIZE);
264
265 return size;
266}
267
268size_t fat_lfn_get_entry(const fat_dentry_t *d, uint16_t *dst, size_t *offset)
269{
270 int i;
271 for (i=1; i>=0 && *offset>0; i--) {
272 if (d->lfn.part3[i] == 0 || d->lfn.part3[i] == FAT_LFN_PAD)
273 continue;
274 (*offset)--;
275 dst[(*offset)] = uint16_t_le2host(d->lfn.part3[i]);
276 }
277 for (i=5; i>=0 && *offset>0; i--) {
278 if (d->lfn.part2[i] == 0 || d->lfn.part2[i] == FAT_LFN_PAD)
279 continue;
280 (*offset)--;
281 dst[(*offset)] = uint16_t_le2host(d->lfn.part2[i]);
282 }
283 for (i=4; i>=0 && *offset>0; i--) {
284 if (d->lfn.part1[i] == 0 || d->lfn.part1[i] == FAT_LFN_PAD)
285 continue;
286 (*offset)--;
287 dst[(*offset)] = uint16_t_le2host(d->lfn.part1[i]);
288 }
289 return *offset;
290}
291
292size_t fat_lfn_set_entry(const uint16_t *src, size_t *offset, size_t size, fat_dentry_t *d)
293{
294 size_t idx;
295 for (idx=0; idx < 5; idx++) {
296 if (*offset < size) {
297 d->lfn.part1[idx] = host2uint16_t_le(src[*offset]);
298 (*offset)++;
299 }
300 else
301 d->lfn.part1[idx] = FAT_LFN_PAD;
302 }
303 for (idx=0; idx < 6; idx++) {
304 if (*offset < size) {
305 d->lfn.part2[idx] = host2uint16_t_le(src[*offset]);
306 (*offset)++;
307 }
308 else
309 d->lfn.part2[idx] = FAT_LFN_PAD;
310 }
311 for (idx=0; idx < 2; idx++) {
312 if (*offset < size) {
313 d->lfn.part3[idx] = host2uint16_t_le(src[*offset]);
314 (*offset)++;
315 }
316 else
317 d->lfn.part3[idx] = FAT_LFN_PAD;
318 }
319
320 if (src[*offset] == 0)
321 offset++;
322 FAT_LFN_ATTR(d) = FAT_ATTR_LFN;
323 d->lfn.type = 0;
324 d->lfn.firstc_lo = 0;
325
326 return *offset;
327}
328
329void str_to_ascii(char *dst, const char *src, size_t count, uint8_t pad)
330{
331 wchar_t ch;
332 size_t off = 0;
333 size_t i = 0;
334
335 while (i < count) {
336 if ((ch = str_decode(src, &off, STR_NO_LIMIT)) != 0) {
337 if (ascii_check(ch) & IS_D_CHAR(ch))
338 *dst = toupper(ch);
339 else
340 *dst = pad;
341 }
342 else
343 break;
344
345 dst++;
346 i++;
347 }
348 *dst = '\0';
349}
350
351bool fat_valid_name(const char *name)
352{
353 wchar_t ch;
354 size_t offset=0;
355 bool result = true;
356
357 while ((ch = str_decode(name, &offset, STR_NO_LIMIT)) != 0) {
358 if (wstr_chr(FAT_STOP_CHARS, ch) != NULL) {
359 result = false;
360 break;
361 }
362 }
363 return result;
364}
365
366bool fat_valid_short_name(const char *name)
367{
368 unsigned int i;
369 unsigned int dot = 0;
370 bool dot_found = false;
371
372 for (i = 0; name[i]; i++) {
373 if (name[i] == '.') {
374 if (dot_found) {
375 return false;
376 } else {
377 dot_found = true;
378 dot = i;
379 }
380 } else {
381 if (!IS_D_CHAR(name[i]))
382 return false;
383 }
384 }
385
386 if (dot_found) {
387 if (dot > FAT_NAME_LEN)
388 return false;
389 if (i - dot > FAT_EXT_LEN + 1)
390 return false;
391 } else {
392 if (i > FAT_NAME_LEN)
393 return false;
394 }
395
396 return true;
397}
398
399size_t utf16_length(const uint16_t *wstr)
400{
401 size_t len = 0;
402
403 while (*wstr++ != 0)
404 len++;
405
406 return len;
407}
408
409/**
410 * @}
411 */
Note: See TracBrowser for help on using the repository browser.