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 afe0ef0577bd687833c4906405585ec475da30c7..3a85fbd90c10a7c2a4344c4d59f1b039ffaa82a4 100644 (file)
--- 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 35354232883e837e768f80378722f438731b3c65..8fb9abd0a136ed555b277065284d9eadbb77c112 100644 (file)
--- 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 b93b55ac98f1788b60b4781272de3d034a318ac0..e58516aa60e053732f52adea56f0f25be26f193d 100644 (file)
--- 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 37d6cae1d0cce812d4217f6444c06fbaf8360dd5..54905f7cf79153421356e60ab0307f70fe815a25 100644 (file)
--- 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 7860b848f21548cc4c6f3432425e839c94893344..d1f1fb1302e047f8358151c1a38d22fa01eeb4ad 100644 (file)
--- 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 9ade09b54e51680c7c507b3bc21566108144bbc6..789f8e2bf6cc0b3aca70ac1e15cda590b58216dc 100644 (file)
--- 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 487b03e19fd9a6f0fb06800f7dde867602ccdc16..b04ade5ba36cff55ecd09bc21ae23a8388ca7aac 100644 (file)
--- 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 666d909bf6018299da92aa522f51f6b1824c6831..ae32bf83a0e88db26139f574a96934562209a9dd 100644 (file)
--- 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 d8194754a8f3c49dd20e28b982b681095b73191a..c07206201abd0b8479b3f178ea958efa50c79779 100644 (file)
--- 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"