From: Charles Manning <cdhmanning@gmail.com>
Date: Sun, 29 Jan 2012 18:27:38 +0000 (+1300)
Subject: Add case insensitive features for yaffs direct.
X-Git-Url: https://yaffs.net/gitweb/?p=yaffs2.git;a=commitdiff_plain;h=75656a2607c8ab2e94595c7ea0a30f36848749a1

Add case insensitive features for yaffs direct.

Signed-off-by: Charles Manning <cdhmanning@gmail.com>
---

diff --git a/direct/basic-test/Makefile b/direct/basic-test/Makefile
index afe0ef0..3a85fbd 100644
--- a/direct/basic-test/Makefile
+++ b/direct/basic-test/Makefile
@@ -24,6 +24,7 @@ CFLAGS +=    -Wall -g $(EXTRA_COMPILE_FLAGS) -Werror=strict-aliasing
 #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
diff --git a/direct/basic-test/dtest.c b/direct/basic-test/dtest.c
index 3535423..8fb9abd 100644
--- a/direct/basic-test/dtest.c
+++ b/direct/basic-test/dtest.c
@@ -20,6 +20,7 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <time.h>
+#include <ctype.h>
 
 #include "yaffsfs.h"
 
@@ -2797,6 +2798,59 @@ void max_files_test(const char *mountpt)
 
 }
 
+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");
@@ -2877,9 +2931,11 @@ int main(int argc, char *argv[])
 	 //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;
 
diff --git a/direct/yaffs_nandif.c b/direct/yaffs_nandif.c
index b93b55a..e58516a 100644
--- a/direct/yaffs_nandif.c
+++ b/direct/yaffs_nandif.c
@@ -216,12 +216,12 @@ struct yaffs_dev *
 	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;
diff --git a/direct/yaffsfs.c b/direct/yaffsfs.c
index 37d6cae..54905f7 100644
--- a/direct/yaffsfs.c
+++ b/direct/yaffsfs.c
@@ -380,13 +380,28 @@ static void yaffsfs_BreakDeviceHandles(struct yaffs_dev *dev)
 /*
  *  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)
 {
@@ -405,7 +420,7 @@ int yaffsfs_CheckNameLength(const char *name)
 {
 	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);
@@ -430,7 +445,7 @@ static int yaffsfs_alt_dir_path(const YCHAR *path, YCHAR **ret_path)
 	 * 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.
@@ -650,9 +665,9 @@ static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,
 			/* 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);
@@ -1430,7 +1445,7 @@ int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
 		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);
@@ -1518,7 +1533,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 	} 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) {
@@ -2379,7 +2394,7 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
 		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)
@@ -2873,7 +2888,7 @@ yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
 			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)
@@ -2904,7 +2919,7 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
 			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"));
@@ -2983,7 +2998,7 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 		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);
@@ -3033,7 +3048,7 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 	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();
diff --git a/direct/ydirectenv.h b/direct/ydirectenv.h
index 7860b84..d1f1fb1 100644
--- a/direct/ydirectenv.h
+++ b/direct/ydirectenv.h
@@ -36,6 +36,17 @@
 #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)
diff --git a/yaffs_guts.c b/yaffs_guts.c
index 9ade09b..789f8e2 100644
--- a/yaffs_guts.c
+++ b/yaffs_guts.c
@@ -674,9 +674,9 @@ void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name)
 {
 	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);
@@ -2034,10 +2034,10 @@ YCHAR *yaffs_clone_str(const YCHAR *str)
 	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;
@@ -3210,13 +3210,13 @@ static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR *name,
 				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);
 	}
 }
 
@@ -3253,13 +3253,13 @@ static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR *oh_name,
 		} 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);
 	}
 }
 
@@ -3283,7 +3283,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
 	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;
@@ -3352,7 +3352,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
 		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;
 	}
@@ -4063,11 +4063,11 @@ int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name,
 	 */
 	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;
@@ -4343,7 +4343,7 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
 
 		/* 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
@@ -4351,7 +4351,7 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
 			 */
 			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;
 		}
 	}
@@ -4394,7 +4394,7 @@ static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR *name,
 				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];
@@ -4406,9 +4406,9 @@ static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR *name,
 			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);
 	}
 }
 
@@ -4417,9 +4417,9 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size)
 	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);
@@ -4441,7 +4441,7 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size)
 
 	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)
@@ -4454,7 +4454,7 @@ 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 */
diff --git a/yaffs_nameval.c b/yaffs_nameval.c
index 487b03e..b04ade5 100644
--- a/yaffs_nameval.c
+++ b/yaffs_nameval.c
@@ -37,7 +37,7 @@ static int nval_find(const char *xb, int xb_size, const YCHAR *name,
 
 	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;
@@ -89,7 +89,7 @@ int nval_set(char *xb, int xb_size, const YCHAR *name, const char *buf,
 		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;
@@ -119,7 +119,7 @@ int nval_set(char *xb, int xb_size, const YCHAR *name, const char *buf,
 
 	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;
@@ -178,7 +178,7 @@ int nval_list(const char *xb, int xb_size, char *buf, int bsize)
 		!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;
diff --git a/yportenv_multi.h b/yportenv_multi.h
index 666d909..ae32bf8 100644
--- a/yportenv_multi.h
+++ b/yportenv_multi.h
@@ -53,6 +53,11 @@
 #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"
diff --git a/yportenv_single.h b/yportenv_single.h
index d819475..c072062 100644
--- a/yportenv_single.h
+++ b/yportenv_single.h
@@ -35,6 +35,11 @@
 #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"