#CFLAGS += -fno-strict-aliasing
CFLAGS += -O0
#CFLAGS += -DVALGRIND_TEST
+CFLAGS += -DCONFIG_YAFFS_CASE_INSENSITIVE
CFLAGS+= -Wshadow -Werror=pointer-arith -Werror=write-strings
CFLAGS+= -Werror=strict-prototypes -Werror=missing-parameter-type
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
+#include <ctype.h>
#include "yaffsfs.h"
}
+void case_insensitive_test(const char *mountpt)
+{
+ char fn[100];
+ char fn2[100];
+ char buffer[100];
+ int ret;
+ struct yaffs_stat s;
+ int h;
+ char *x;
+
+ yaffs_trace_mask = 0;
+
+ yaffs_start_up();
+
+ yaffs_mount(mountpt);
+ dump_directory_tree(mountpt);
+
+ sprintf(fn,"%s/Abc.Txt",mountpt);
+ yaffs_unlink(fn);
+ h = yaffs_open(fn, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);
+
+ ret = yaffs_write(h,fn, strlen(fn) + 1);
+
+ ret = yaffs_close(h);
+
+ dump_directory_tree(mountpt);
+
+
+ strcpy(fn2, fn);
+ x = fn2;
+ while(*x) {
+ *x = toupper(*x);
+ x++;
+ }
+
+ h = yaffs_open(fn2, O_RDONLY, 0);
+ ret = yaffs_read(h, buffer, 100);
+
+ if (ret != strlen(fn) + 1 || memcmp(buffer, fn, ret)){
+ printf("wrong file read\n");
+ } else {
+ printf("File %s is the same as file %s\n", fn, fn2);
+ }
+
+ ret = yaffs_stat(fn2, &s);
+
+ printf("renaming\n");
+
+ ret = yaffs_rename(fn, fn2);
+ dump_directory_tree(mountpt);
+
+}
+
void start_twice(const char *mountpt)
{
printf("About to do first yaffs_start\n");
//basic_utime_test("/yaffs2");
//max_files_test("/yaffs2");
-
- start_twice("/yaffs2");
+ //start_twice("/yaffs2");
+#ifdef CONFIG_YAFFS_CASE_INSENSITIVE
+ case_insensitive_test("/yaffs2");
+#endif
return 0;
yaffs_add_dev_from_geometry(const YCHAR *name,
const ynandif_Geometry *geometry)
{
- YCHAR *clonedName = malloc(sizeof(YCHAR) * (strnlen(name,YAFFS_MAX_NAME_LENGTH)+1));
+ YCHAR *clonedName = malloc(sizeof(YCHAR) * (yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH)+1));
struct yaffs_dev *dev = malloc(sizeof(struct yaffs_dev));
if(dev && clonedName){
memset(dev,0,sizeof(struct yaffs_dev));
- strcpy(clonedName,name);
+ yaffs_strcpy(clonedName,name);
dev->param.name = clonedName;
dev->param.write_chunk_tags_fn = ynandif_WriteChunkWithTagsToNAND;
/*
* Stuff to handle names.
*/
+#ifdef CONFIG_YAFFS_CASE_INSENSITIVE
+static int yaffs_toupper(YCHAR a)
+{
+ if(a >= 'a' && a <= 'z')
+ return (a - 'a') + 'A';
+ else
+ return a;
+}
+
+int yaffsfs_Match(YCHAR a, YCHAR b)
+{
+ return (yaffs_toupper(a) == yaffs_toupper(b));
+}
+#else
int yaffsfs_Match(YCHAR a, YCHAR b)
{
/* case sensitive */
return (a == b);
}
+#endif
int yaffsfs_IsPathDivider(YCHAR ch)
{
{
int retVal = 0;
- int nameLength = strnlen(name,YAFFS_MAX_NAME_LENGTH+1);
+ int nameLength = yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH+1);
if(nameLength == 0){
yaffsfs_SetError(-ENOENT);
* We will use 3 * max name length instead.
*/
*ret_path = NULL;
- path_length = strnlen(path,(YAFFS_MAX_NAME_LENGTH+1)*3 +1);
+ path_length = yaffs_strnlen(path,(YAFFS_MAX_NAME_LENGTH+1)*3 +1);
/* If the last character is a path divider, then we need to
* trim it back so that the name look-up works properly.
/* got to the end of the string */
return dir;
else{
- if(strcmp(str,_Y(".")) == 0){
+ if(yaffs_strcmp(str,_Y(".")) == 0){
/* Do nothing */
- } else if(strcmp(str,_Y("..")) == 0) {
+ } else if(yaffs_strcmp(str,_Y("..")) == 0) {
dir = dir->parent;
} else{
dir = yaffs_find_by_name(dir,str);
yaffsfs_SetError(-ELOOP);
else if(!dir)
yaffsfs_SetError(-ENOENT);
- else if(strncmp(name,_Y("."),2) == 0)
+ else if(yaffs_strncmp(name,_Y("."),2) == 0)
yaffsfs_SetError(-EINVAL);
else if(!obj)
yaffsfs_SetError(-ENOENT);
} else if(oldLoop || newLoop) {
yaffsfs_SetError(-ELOOP);
rename_allowed = 0;
- } else if (olddir && oldname && strncmp(oldname, _Y("."),2) == 0){
+ } else if (olddir && oldname && yaffs_strncmp(oldname, _Y("."),2) == 0){
yaffsfs_SetError(-EINVAL);
rename_allowed = 0;
}else if(!olddir || !newdir || !obj) {
yaffsfs_SetError(-ENOENT);
else if(yaffsfs_TooManyObjects(parent->my_dev))
yaffsfs_SetError(-ENFILE);
- else if(strnlen(name,5) == 0){
+ else if(yaffs_strnlen(name,5) == 0){
/* Trying to make the root itself */
yaffsfs_SetError(-EEXIST);
} else if(parent->my_dev->read_only)
memset(dsc,0,sizeof(yaffsfs_DirectorySearchContext));
dsc->magic = YAFFS_MAGIC;
dsc->dirObj = obj;
- strncpy(dsc->name,dirname,NAME_MAX);
+ yaffs_strncpy(dsc->name,dirname,NAME_MAX);
INIT_LIST_HEAD(&dsc->others);
if(!search_contexts.next)
dsc->de.d_dont_use = (unsigned)dsc->nextReturn;
dsc->de.d_off = dsc->offset++;
yaffs_get_obj_name(dsc->nextReturn,dsc->de.d_name,NAME_MAX);
- if(strnlen(dsc->de.d_name,NAME_MAX+1) == 0)
+ if(yaffs_strnlen(dsc->de.d_name,NAME_MAX+1) == 0)
{
/* this should not happen! */
strcpy(dsc->de.d_name,_Y("zz"));
yaffsfs_SetError(-ENOTDIR);
else if(loop)
yaffsfs_SetError(-ELOOP);
- else if( !parent || strnlen(name,5) < 1)
+ else if( !parent || yaffs_strnlen(name,5) < 1)
yaffsfs_SetError(-ENOENT);
else if(yaffsfs_TooManyObjects(parent->my_dev))
yaffsfs_SetError(-ENFILE);
else {
YCHAR *alias = obj->variant.symlink_variant.alias;
memset(buf,0,bufsiz);
- strncpy(buf,alias,bufsiz - 1);
+ yaffs_strncpy(buf,alias,bufsiz - 1);
retVal = 0;
}
yaffsfs_Unlock();
#define YCHAR char
#define YUCHAR unsigned char
#define _Y(x) x
+#define yaffs_strcat(a,b) strcat(a,b)
+#define yaffs_strcpy(a,b) strcpy(a,b)
+#define yaffs_strncpy(a,b,c) strncpy(a,b,c)
+#define yaffs_strnlen(s,m) strnlen(s,m)
+#ifdef CONFIG_YAFFS_CASE_INSENSITIVE
+#define yaffs_strcmp(a,b) strcasecmp(a,b)
+#define yaffs_strncmp(a,b,c) strncasecmp(a,b,c)
+#else
+#define yaffs_strcmp(a,b) strcmp(a,b)
+#define yaffs_strncmp(a,b,c) strncmp(a,b,c)
+#endif
#define hweight8(x) yaffs_hweight8(x)
#define hweight32(x) yaffs_hweight32(x)
{
memset(obj->short_name, 0, sizeof(obj->short_name));
if (name &&
- strnlen(name, YAFFS_SHORT_NAME_LENGTH + 1) <=
+ yaffs_strnlen(name, YAFFS_SHORT_NAME_LENGTH + 1) <=
YAFFS_SHORT_NAME_LENGTH)
- strcpy(obj->short_name, name);
+ yaffs_strcpy(obj->short_name, name);
else
obj->short_name[0] = _Y('\0');
obj->sum = yaffs_calc_name_sum(name);
if (!str)
str = _Y("");
- len = strnlen(str, YAFFS_MAX_ALIAS_LENGTH);
+ len = yaffs_strnlen(str, YAFFS_MAX_ALIAS_LENGTH);
new_str = kmalloc((len + 1) * sizeof(YCHAR), GFP_NOFS);
if (new_str) {
- strncpy(new_str, str, len);
+ yaffs_strncpy(new_str, str, len);
new_str[len] = 0;
}
return new_str;
n--;
}
} else {
- strncpy(name, oh_name + 1, buff_size - 1);
+ yaffs_strncpy(name, oh_name + 1, buff_size - 1);
}
} else {
#else
{
#endif
- strncpy(name, oh_name, buff_size - 1);
+ yaffs_strncpy(name, oh_name, buff_size - 1);
}
}
} else {
/* Unicode name, so save starting at the second YCHAR */
*oh_name = 0;
- strncpy(oh_name + 1, name, YAFFS_MAX_NAME_LENGTH - 2);
+ yaffs_strncpy(oh_name + 1, name, YAFFS_MAX_NAME_LENGTH - 2);
}
} else {
#else
{
#endif
- strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1);
+ yaffs_strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1);
}
}
YCHAR old_name[YAFFS_MAX_NAME_LENGTH + 1];
struct yaffs_obj_hdr *oh = NULL;
- strcpy(old_name, _Y("silly old name"));
+ yaffs_strcpy(old_name, _Y("silly old name"));
if (in->fake && in != dev->root_dir && !force && !xmod)
return ret_val;
alias = in->variant.symlink_variant.alias;
if (!alias)
alias = _Y("no alias");
- strncpy(oh->alias, alias, YAFFS_MAX_ALIAS_LENGTH);
+ yaffs_strncpy(oh->alias, alias, YAFFS_MAX_ALIAS_LENGTH);
oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0;
break;
}
*/
if (old_dir == new_dir &&
old_name && new_name &&
- strcmp(old_name, new_name) == 0)
+ yaffs_strcmp(old_name, new_name) == 0)
force = 1;
#endif
- if (strnlen(new_name, YAFFS_MAX_NAME_LENGTH + 1) >
+ if (yaffs_strnlen(new_name, YAFFS_MAX_NAME_LENGTH + 1) >
YAFFS_MAX_NAME_LENGTH)
/* ENAMETOOLONG */
return YAFFS_FAIL;
/* Special case for lost-n-found */
if (l->obj_id == YAFFS_OBJECTID_LOSTNFOUND) {
- if (!strcmp(name, YAFFS_LOSTNFOUND_NAME))
+ if (!yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME))
return l;
} else if (l->sum == sum || l->hdr_chunk <= 0) {
/* LostnFound chunk called Objxxx
*/
yaffs_get_obj_name(l, buffer,
YAFFS_MAX_NAME_LENGTH + 1);
- if (strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH) == 0)
+ if (yaffs_strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH) == 0)
return l;
}
}
int buffer_size)
{
/* Create an object name if we could not find one. */
- if (strnlen(name, YAFFS_MAX_NAME_LENGTH) == 0) {
+ if (yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH) == 0) {
YCHAR local_name[20];
YCHAR num_string[20];
YCHAR *x = &num_string[19];
v /= 10;
}
/* make up a name */
- strcpy(local_name, YAFFS_LOSTNFOUND_PREFIX);
- strcat(local_name, x);
- strncpy(name, local_name, buffer_size - 1);
+ yaffs_strcpy(local_name, YAFFS_LOSTNFOUND_PREFIX);
+ yaffs_strcat(local_name, x);
+ yaffs_strncpy(name, local_name, buffer_size - 1);
}
}
memset(name, 0, buffer_size * sizeof(YCHAR));
yaffs_check_obj_details_loaded(obj);
if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND) {
- strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1);
+ yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1);
} else if (obj->short_name[0]) {
- strcpy(name, obj->short_name);
+ yaffs_strcpy(name, obj->short_name);
} else if (obj->hdr_chunk > 0) {
int result;
u8 *buffer = yaffs_get_temp_buffer(obj->my_dev);
yaffs_fix_null_name(obj, name, buffer_size);
- return strnlen(name, YAFFS_MAX_NAME_LENGTH);
+ return yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH);
}
int yaffs_get_obj_length(struct yaffs_obj *obj)
if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) {
if (!obj->variant.symlink_variant.alias)
return 0;
- return strnlen(obj->variant.symlink_variant.alias,
+ return yaffs_strnlen(obj->variant.symlink_variant.alias,
YAFFS_MAX_ALIAS_LENGTH);
} else {
/* Only a directory should drop through to here */
memcpy(&size, xb, sizeof(int));
while (size > 0 && (size < xb_size) && (pos + size < xb_size)) {
- if (!strncmp((YCHAR *) (xb + pos + sizeof(int)), name, size)) {
+ if (!yaffs_strncmp((YCHAR *) (xb + pos + sizeof(int)), name, size)) {
if (exist_size)
*exist_size = size;
return pos;
int bsize, int flags)
{
int pos;
- int namelen = strnlen(name, xb_size);
+ int namelen = yaffs_strnlen(name, xb_size);
int reclen;
int size_exist = 0;
int space;
memcpy(xb + pos, &reclen, sizeof(int));
pos += sizeof(int);
- strncpy((YCHAR *) (xb + pos), name, reclen);
+ yaffs_strncpy((YCHAR *) (xb + pos), name, reclen);
pos += (namelen + 1);
memcpy(xb + pos, buf, bsize);
return 0;
!filled) {
pos += sizeof(int);
size -= sizeof(int);
- name_len = strnlen((YCHAR *) (xb + pos), size);
+ name_len = yaffs_strnlen((YCHAR *) (xb + pos), size);
if (ncopied + name_len + 1 < bsize) {
memcpy(buf, xb + pos, name_len * sizeof(YCHAR));
buf += name_len;
#define YCHAR char
#define YUCHAR unsigned char
#define _Y(x) x
+#define yaffs_strcat(a, b) strcat(a, b)
+#define yaffs_strcpy(a, b) strcpy(a, b)
+#define yaffs_strncpy(a, b, c) strncpy(a, b, c)
+#define yaffs_strncmp(a, b, c) strncmp(a, b, c)
+#define yaffs_strnlen(s,m) strnlen(s,m)
#define YAFFS_LOSTNFOUND_NAME "lost+found"
#define YAFFS_LOSTNFOUND_PREFIX "obj"
#define YCHAR char
#define YUCHAR unsigned char
#define _Y(x) x
+#define yaffs_strcat(a, b) strcat(a, b)
+#define yaffs_strcpy(a, b) strcpy(a, b)
+#define yaffs_strncpy(a, b, c) strncpy(a, b, c)
+#define yaffs_strncmp(a, b, c) strncmp(a, b, c)
+#define yaffs_strnlen(s,m) strnlen(s,m)
#define YAFFS_LOSTNFOUND_NAME "lost+found"
#define YAFFS_LOSTNFOUND_PREFIX "obj"