WebSVN – HelenOS – Diff – /branches/dynload/uspace/srv/fs/fat/fat_dentry.c


/*
 * Copyright (c) 2008 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - 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.
 * - 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.
 */
 
/** @addtogroup fs
 * @{
 */
 
/**
 * @file    fat_dentry.c
 * @brief   Functions that work with FAT directory entries.
 */
 
#include "fat_dentry.h"
#include <ctype.h>
#include <string.h>
 
static bool is_d_char(const char ch)
{
    if (isalnum(ch) || ch == '_')
        return true;
    else
        return false;
}
 
/** Compare path component with the name read from the dentry.
 *
 * This function compares the path component with the name read from the dentry.
 * The comparison is case insensitive and tolerates a mismatch on the trailing
 * dot character at the end of the name (i.e. when there is a dot, but no
 * extension).
 *
 * @param name      Node name read from the dentry.
 * @param component Path component.
 *
 * @return      Zero on match, non-zero otherwise.
 */
int fat_dentry_namecmp(char *name, const char *component)
{
    int rc;
    size_t size;
 
    if (!(rc = stricmp(name, component)))
        return rc;
    if (!str_chr(name, '.')) {
        /*
         * There is no '.' in the name, so we know that there is enough
         * space for appending an extra '.' to name.
         */
        size = str_size(name);
        name[size] = '.';
        name[size + 1] = '\0';
        rc = stricmp(name, component);
    }
    return rc;
}
 
bool fat_dentry_name_verify(const char *name)
{
    unsigned i, dot;
    bool dot_found = false;
   
 
    for (i = 0; name[i]; i++) {
        if (name[i] == '.') {
            if (dot_found) {
                return false;
            } else {
                dot_found = true;
                dot = i;
            }
        } else {
            if (!is_d_char(name[i]))
                return false;
        }
    }
 
    if (dot_found) {
        if (dot > FAT_NAME_LEN)
            return false;
        if (i - dot > FAT_EXT_LEN + 1)
            return false;
    } else {
        if (i > FAT_NAME_LEN)
            return false;
    }
 
    return true;
}
 
void fat_dentry_name_get(const fat_dentry_t *d, char *buf)
{
    unsigned int i;
   
    for (i = 0; i < FAT_NAME_LEN; i++) {
        if (d->name[i] == FAT_PAD)
            break;
       
        if (d->name[i] == FAT_DENTRY_E5_ESC)
            *buf++ = 0xe5;
        else {
            if (d->lcase & FAT_LCASE_LOWER_NAME)
                *buf++ = tolower(d->name[i]);
            else
                *buf++ = d->name[i];
        }
    }
   
    if (d->ext[0] != FAT_PAD)
        *buf++ = '.';
   
    for (i = 0; i < FAT_EXT_LEN; i++) {
        if (d->ext[i] == FAT_PAD) {
            *buf = '\0';
            return;
        }
       
        if (d->ext[i] == FAT_DENTRY_E5_ESC)
            *buf++ = 0xe5;
        else {
            if (d->lcase & FAT_LCASE_LOWER_EXT)
                *buf++ = tolower(d->ext[i]);
            else
                *buf++ = d->ext[i];
        }
    }
   
    *buf = '\0';
}
 
void fat_dentry_name_set(fat_dentry_t *d, const char *name)
{
    unsigned int i;
    const char fake_ext[] = "   ";
 
    bool lower_name = true;
    bool lower_ext = true;
   
    for (i = 0; i < FAT_NAME_LEN; i++) {
        switch ((uint8_t) *name) {
        case 0xe5:
            d->name[i] = FAT_DENTRY_E5_ESC;
            name++;
            break;
        case '\0':
        case '.':
            d->name[i] = FAT_PAD;
            break;
        default:
            if (isalpha(*name)) {
                if (!islower(*name))
                    lower_name = false;
            }
           
            d->name[i] = toupper(*name++);
            break;
        }
    }
   
    if (*name++ != '.')
        name = fake_ext;
   
    for (i = 0; i < FAT_EXT_LEN; i++) {
        switch ((uint8_t) *name) {
        case 0xe5:
            d->ext[i] = FAT_DENTRY_E5_ESC;
            name++;
            break;
        case '\0':
            d->ext[i] = FAT_PAD;
            break;
        default:
            if (isalpha(*name)) {
                if (!islower(*name))
                    lower_ext = false;
            }
           
            d->ext[i] = toupper(*name++);
            break;
        }
    }
   
    if (lower_name)
        d->lcase |= FAT_LCASE_LOWER_NAME;
    else
        d->lcase &= ~FAT_LCASE_LOWER_NAME;
   
    if (lower_ext)
        d->lcase |= FAT_LCASE_LOWER_EXT;
    else
        d->lcase &= ~FAT_LCASE_LOWER_EXT;
}
 
fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *d)
{
    if (d->attr & FAT_ATTR_VOLLABEL) {
        /* volume label entry */
        return FAT_DENTRY_SKIP;
    }
    if (d->name[0] == FAT_DENTRY_ERASED) {
        /* not-currently-used entry */
        return FAT_DENTRY_FREE;
    }
    if (d->name[0] == FAT_DENTRY_UNUSED) {
        /* never used entry */
        return FAT_DENTRY_LAST;
    }
    if (d->name[0] == FAT_DENTRY_DOT) {
        /*
         * Most likely '.' or '..'.
         * It cannot occur in a regular file name.
         */
        return FAT_DENTRY_SKIP;
    }
    return FAT_DENTRY_VALID;
}
 
/**
 * @}
 */
 

Rev 4348	Rev 4389
1	/*	1	/*
2	* Copyright (c) 2008 Jakub Jermar	2	* Copyright (c) 2008 Jakub Jermar
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup fs	29	/** @addtogroup fs
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/**	33	/**
34	* @file fat_dentry.c	34	* @file fat_dentry.c
35	* @brief Functions that work with FAT directory entries.	35	* @brief Functions that work with FAT directory entries.
36	*/	36	*/
37		37
38	#include "fat_dentry.h"	38	#include "fat_dentry.h"
39	#include <ctype.h>	39	#include <ctype.h>
40	#include <string.h>	40	#include <string.h>
41		41
42	static bool is_d_char(const char ch)	42	static bool is_d_char(const char ch)
43	{	43	{
44	if (isalnum(ch) \|\| ch == '_')	44	if (isalnum(ch) \|\| ch == '_')
45	return true;	45	return true;
46	else	46	else
47	return false;	47	return false;
48	}	48	}
49		49
50	/** Compare path component with the name read from the dentry.	50	/** Compare path component with the name read from the dentry.
51	*	51	*
52	* This function compares the path component with the name read from the dentry.	52	* This function compares the path component with the name read from the dentry.
53	* The comparison is case insensitive and tolerates a mismatch on the trailing	53	* The comparison is case insensitive and tolerates a mismatch on the trailing
54	* dot character at the end of the name (i.e. when there is a dot, but no	54	* dot character at the end of the name (i.e. when there is a dot, but no
55	* extension).	55	* extension).
56	*	56	*
57	* @param name Node name read from the dentry.	57	* @param name Node name read from the dentry.
58	* @param component Path component.	58	* @param component Path component.
59	*	59	*
60	* @return Zero on match, non-zero otherwise.	60	* @return Zero on match, non-zero otherwise.
61	*/	61	*/
62	int fat_dentry_namecmp(char name, const char component)	62	int fat_dentry_namecmp(char name, const char component)
63	{	63	{
64	int rc;	64	int rc;
65	size_t size;	65	size_t size;
66		66
67	if (!(rc = stricmp(name, component)))	67	if (!(rc = stricmp(name, component)))
68	return rc;	68	return rc;
69	if (!str_chr(name, '.')) {	69	if (!str_chr(name, '.')) {
70	/*	70	/*
71	* There is no '.' in the name, so we know that there is enough	71	* There is no '.' in the name, so we know that there is enough
72	* space for appending an extra '.' to name.	72	* space for appending an extra '.' to name.
73	*/	73	*/
74	size = str_size(name);	74	size = str_size(name);
75	name[size] = '.';	75	name[size] = '.';
76	name[size + 1] = '\0';	76	name[size + 1] = '\0';
77	rc = stricmp(name, component);	77	rc = stricmp(name, component);
78	}	78	}
79	return rc;	79	return rc;
80	}	80	}
81		81
82	bool fat_dentry_name_verify(const char *name)	82	bool fat_dentry_name_verify(const char *name)
83	{	83	{
84	unsigned i, dot;	84	unsigned i, dot;
85	bool dot_found = false;	85	bool dot_found = false;
86		86
87		87
88	for (i = 0; name[i]; i++) {	88	for (i = 0; name[i]; i++) {
89	if (name[i] == '.') {	89	if (name[i] == '.') {
90	if (dot_found) {	90	if (dot_found) {
91	return false;	91	return false;
92	} else {	92	} else {
93	dot_found = true;	93	dot_found = true;
94	dot = i;	94	dot = i;
95	}	95	}
96	} else {	96	} else {
97	if (!is_d_char(name[i]))	97	if (!is_d_char(name[i]))
98	return false;	98	return false;
99	}	99	}
100	}	100	}
101		101
102	if (dot_found) {	102	if (dot_found) {
103	if (dot > FAT_NAME_LEN)	103	if (dot > FAT_NAME_LEN)
104	return false;	104	return false;
105	if (i - dot > FAT_EXT_LEN + 1)	105	if (i - dot > FAT_EXT_LEN + 1)
106	return false;	106	return false;
107	} else {	107	} else {
108	if (i > FAT_NAME_LEN)	108	if (i > FAT_NAME_LEN)
109	return false;	109	return false;
110	}	110	}
111		111
112	return true;	112	return true;
113	}	113	}
114		114
115	void fat_dentry_name_get(const fat_dentry_t d, char buf)	115	void fat_dentry_name_get(const fat_dentry_t d, char buf)
116	{	116	{
117	int i;	117	unsigned int i;
118		118
119	for (i = 0; i < FAT_NAME_LEN; i++) {	119	for (i = 0; i < FAT_NAME_LEN; i++) {
120	if (d->name[i] == FAT_PAD)	120	if (d->name[i] == FAT_PAD)
121	break;	121	break;
-		122
122	if (d->name[i] == FAT_DENTRY_E5_ESC)	123	if (d->name[i] == FAT_DENTRY_E5_ESC)
123	*buf++ = 0xe5;	124	*buf++ = 0xe5;
-		125	else {
-		126	if (d->lcase & FAT_LCASE_LOWER_NAME)
-		127	*buf++ = tolower(d->name[i]);
124	else	128	else
125	*buf++ = d->name[i];	129	*buf++ = d->name[i];
-		130	}
126	}	131	}
-		132
127	if (d->ext[0] != FAT_PAD)	133	if (d->ext[0] != FAT_PAD)
128	*buf++ = '.';	134	*buf++ = '.';
-		135
129	for (i = 0; i < FAT_EXT_LEN; i++) {	136	for (i = 0; i < FAT_EXT_LEN; i++) {
130	if (d->ext[i] == FAT_PAD) {	137	if (d->ext[i] == FAT_PAD) {
131	*buf = '\0';	138	*buf = '\0';
132	return;	139	return;
133	}	140	}
-		141
134	if (d->ext[i] == FAT_DENTRY_E5_ESC)	142	if (d->ext[i] == FAT_DENTRY_E5_ESC)
135	*buf++ = 0xe5;	143	*buf++ = 0xe5;
-		144	else {
-		145	if (d->lcase & FAT_LCASE_LOWER_EXT)
-		146	*buf++ = tolower(d->ext[i]);
136	else	147	else
137	*buf++ = d->ext[i];	148	*buf++ = d->ext[i];
-		149	}
138	}	150	}
-		151
139	*buf = '\0';	152	*buf = '\0';
140	}	153	}
141		154
142	void fat_dentry_name_set(fat_dentry_t d, const char name)	155	void fat_dentry_name_set(fat_dentry_t d, const char name)
143	{	156	{
144	int i;	157	unsigned int i;
145	const char fake_ext[] = " ";	158	const char fake_ext[] = " ";
146		-
-		159	bool lower_name = true;
-		160	bool lower_ext = true;
147		161
148	for (i = 0; i < FAT_NAME_LEN; i++) {	162	for (i = 0; i < FAT_NAME_LEN; i++) {
149	switch ((uint8_t) *name) {	163	switch ((uint8_t) *name) {
150	case 0xe5:	164	case 0xe5:
151	d->name[i] = FAT_DENTRY_E5_ESC;	165	d->name[i] = FAT_DENTRY_E5_ESC;
152	name++;	166	name++;
153	break;	167	break;
154	case '\0':	168	case '\0':
155	case '.':	169	case '.':
156	d->name[i] = FAT_PAD;	170	d->name[i] = FAT_PAD;
157	break;	171	break;
158	default:	172	default:
-		173	if (isalpha(*name)) {
-		174	if (!islower(*name))
-		175	lower_name = false;
-		176	}
-		177
159	d->name[i] = toupper(*name++);	178	d->name[i] = toupper(*name++);
160	break;	179	break;
161	}	180	}
162	}	181	}
-		182
163	if (*name++ != '.')	183	if (*name++ != '.')
164	name = fake_ext;	184	name = fake_ext;
-		185
165	for (i = 0; i < FAT_EXT_LEN; i++) {	186	for (i = 0; i < FAT_EXT_LEN; i++) {
166	switch ((uint8_t) *name) {	187	switch ((uint8_t) *name) {
167	case 0xe5:	188	case 0xe5:
168	d->ext[i] = FAT_DENTRY_E5_ESC;	189	d->ext[i] = FAT_DENTRY_E5_ESC;
169	name++;	190	name++;
170	break;	191	break;
171	case '\0':	192	case '\0':
172	d->ext[i] = FAT_PAD;	193	d->ext[i] = FAT_PAD;
173	break;	194	break;
174	default:	195	default:
-		196	if (isalpha(*name)) {
-		197	if (!islower(*name))
-		198	lower_ext = false;
-		199	}
-		200
175	d->ext[i] = toupper(*name++);	201	d->ext[i] = toupper(*name++);
176	break;	202	break;
177	}	203	}
178	}	204	}
-		205
-		206	if (lower_name)
-		207	d->lcase \|= FAT_LCASE_LOWER_NAME;
-		208	else
-		209	d->lcase &= ~FAT_LCASE_LOWER_NAME;
-		210
-		211	if (lower_ext)
-		212	d->lcase \|= FAT_LCASE_LOWER_EXT;
-		213	else
-		214	d->lcase &= ~FAT_LCASE_LOWER_EXT;
179	}	215	}
180		216
181	fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *d)	217	fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *d)
182	{	218	{
183	if (d->attr & FAT_ATTR_VOLLABEL) {	219	if (d->attr & FAT_ATTR_VOLLABEL) {
184	/* volume label entry */	220	/* volume label entry */
185	return FAT_DENTRY_SKIP;	221	return FAT_DENTRY_SKIP;
186	}	222	}
187	if (d->name[0] == FAT_DENTRY_ERASED) {	223	if (d->name[0] == FAT_DENTRY_ERASED) {
188	/* not-currently-used entry */	224	/* not-currently-used entry */
189	return FAT_DENTRY_FREE;	225	return FAT_DENTRY_FREE;
190	}	226	}
191	if (d->name[0] == FAT_DENTRY_UNUSED) {	227	if (d->name[0] == FAT_DENTRY_UNUSED) {
192	/* never used entry */	228	/* never used entry */
193	return FAT_DENTRY_LAST;	229	return FAT_DENTRY_LAST;
194	}	230	}
195	if (d->name[0] == FAT_DENTRY_DOT) {	231	if (d->name[0] == FAT_DENTRY_DOT) {
196	/*	232	/*
197	* Most likely '.' or '..'.	233	* Most likely '.' or '..'.
198	* It cannot occur in a regular file name.	234	* It cannot occur in a regular file name.
199	*/	235	*/
200	return FAT_DENTRY_SKIP;	236	return FAT_DENTRY_SKIP;
201	}	237	}
202	return FAT_DENTRY_VALID;	238	return FAT_DENTRY_VALID;
203	}	239	}
204		240
205	/**	241	/**
206	* @}	242	* @}
207	*/	243	*/
208		244

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/srv/fs/fat/fat_dentry.c – Rev 4348 → 4389