yaffs direct: Clean up and handle names that are to long

[yaffs2.git] / direct / yaffsfs.c

diff --git a/direct/yaffsfs.c b/direct/yaffsfs.c
index 5c583b9d39d44c9de2f16205c2756ce8c65a8148..3f18f7b002b439a3370c74a76b4daa702a6b5c06 100644 (file)
--- a/direct/yaffsfs.c
+++ b/direct/yaffsfs.c
@@ -67,6 +67,18 @@ static yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
 static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
 static int yaffsfs_handlesInitialised;
 
+unsigned int yaffs_trace_mask;
+
+int yaffs_set_trace(unsigned int tm) 
+{
+       return yaffs_trace_mask=tm;
+}
+
+unsigned int yaffs_get_trace(void)
+{
+       return yaffs_trace_mask;
+}
+
 /*
  * yaffsfs_InitHandle
  * Inilitalise handle management on start-up.
@@ -265,7 +277,7 @@ static int yaffsfs_PutHandle(int handle)
 
 
 /*
- *  Stuff to search for a directory from a path
+ *  Stuff to handle names.
  */
 
 
@@ -288,7 +300,22 @@ int yaffsfs_IsPathDivider(YCHAR ch)
        return 0;
 }
 
+int yaffsfs_CheckNameLength(const char *name)
+{
+       int retVal = 0;         
 
+       new_nameLength = yaffs_strnlen(newname,YAFFS_MAX_NAME_LENGTH+1);
+               
+       if(new_nameLength == 0){
+               yaffsfs_SetError(-ENOENT);
+               retVal = -1;
+       } else if (new_nameLength > YAFFS_MAX_NAME_LENGTH){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               retVal = -1;
+       }
+
+       return retVal;  
+}
 
 LIST_HEAD(yaffsfs_deviceList);
 
@@ -370,48 +397,6 @@ static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPat
        return retval;
 }
 
-#if 0
-static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
-{
-       yaffsfs_DeviceConfiguration *cfg = yaffsfs_configurationList;
-       const YCHAR *leftOver;
-       const YCHAR *p;
-       struct yaffs_dev *retval = NULL;
-       int thisMatchLength;
-       int longestMatch = -1;
-
-       /*
-        * Check all configs, choose the one that:
-        * 1) Actually matches a prefix (ie /a amd /abc will not match
-        * 2) Matches the longest.
-        */
-       while(cfg && cfg->prefix && cfg->dev){
-               leftOver = path;
-               p = cfg->prefix;
-               thisMatchLength = 0;
-
-               while(*p &&  /* unmatched part of prefix */
-                     !(yaffsfs_IsPathDivider(*p) && (p[1] == 0)) &&
-                     *leftOver && yaffsfs_Match(*p,*leftOver)){
-                       p++;
-                       leftOver++;
-                       thisMatchLength++;
-               }
-
-
-               if((!*p || (yaffsfs_IsPathDivider(*p) && (p[1] == 0))) &&  /* end of prefix */
-                  (!*leftOver || yaffsfs_IsPathDivider(*leftOver)) && /* no more in this path name part */
-                  (thisMatchLength > longestMatch)){
-                       /* Matched prefix */
-                       *restOfPath = (YCHAR *)leftOver;
-                       retval = cfg->dev;
-                       longestMatch = thisMatchLength;
-               }
-               cfg++;
-       }
-       return retval;
-}
-#endif
 
 static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
 {
@@ -629,6 +614,7 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                        obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
                        obj = NULL;
 
+
                if(obj){
 
                        /* The file already exists or it might be a directory */
@@ -643,7 +629,7 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                        /* Open should fail if O_CREAT and O_EXCL are specified since
                         * the file exists
                         */
-                       if((oflag & O_EXCL) && (oflag & O_CREAT)){
+                       if(!errorReported && (oflag & O_EXCL) && (oflag & O_CREAT)){
                                openDenied = 1;
                                yaffsfs_SetError(-EEXIST);
                                errorReported = 1;
@@ -656,8 +642,14 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                        if( writeRequested && !(obj->yst_mode & S_IWRITE))
                                openDenied = 1;
 
+                       if(openDenied && !errorReported ) {
+                               /* Error if the file exists but permissions are refused. */
+                               yaffsfs_SetError(-EACCES);
+                               errorReported = 1;
+                       }
+
                        /* Check sharing of an existing object. */
-                       {
+                       if(!openDenied){
                                yaffsfs_Handle *hx;
                                int i;
                                sharedReadAllowed = 1;
@@ -692,20 +684,39 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                                }
                        }
 
-               } else if((oflag & O_CREAT)) {
-                       /* Let's see if we can create this file */
+               }
+
+               /* If we could not open an existing object, then let's see if
+                * the directory exists. If not, error.
+                */
+               if(!obj && !errorReported){
                        dir = yaffsfs_FindDirectory(NULL,path,&name,0);
-                       if(dir  && dir->my_dev->read_only){
+                       if(!dir){
+                               yaffsfs_SetError(-ENOTDIR);
+                               errorReported = 1;
+                       }
+               }
+
+               if(!obj && dir && !errorReported && (oflag & O_CREAT)) {
+                       /* Let's see if we can create this file if it does not exist. */
+                       if(dir->my_dev->read_only){
                                yaffsfs_SetError(-EINVAL);
                                errorReported = 1;
-                       } else if(dir)
+                       } else
                                obj = yaffs_create_file(dir,name,mode,0,0);
-                       else {
-                               yaffsfs_SetError(-ENOTDIR);
+
+                       if(!obj && !errorReported){
+                               yaffsfs_SetError(-ENOSPC);
                                errorReported = 1;
                        }
                }
 
+               if(!obj && dir && !errorReported && !(oflag & O_CREAT)) {
+                       /* Error if the file does not exist and CREAT is not set. */
+                       yaffsfs_SetError(-ENOENT);
+                       errorReported = 1;
+               }
+
                if(obj && !openDenied) {
                        int inodeId = yaffsfs_GetInodeIdForObject(obj);
 
@@ -731,10 +742,8 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                                 yaffs_resize_file(obj,0);
                } else {
                        yaffsfs_PutHandle(handle);
-                       if(!errorReported) {
-                               yaffsfs_SetError(!obj ? -ENOSPC : -EACCES);
-                               errorReported = 1;
-                       }
+                       if(!errorReported) 
+                               yaffsfs_SetError(0); /* Problem */
                        handle = -1;
                }
        }
@@ -1808,7 +1817,7 @@ int yaffs_mount2(const YCHAR *path,int read_only)
        struct yaffs_dev *dev=NULL;
        YCHAR *dummy;
 
-       T(YAFFS_TRACE_ALWAYS,(TSTR("yaffs: Mounting %s" TENDSTR),path));
+       T(YAFFS_TRACE_MOUNT,(TSTR("yaffs: Mounting %s" TENDSTR),path));
 
        yaffsfs_Lock();
 
@@ -2320,15 +2329,7 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
                        retVal = -1;
                }
                
-               new_nameLength = yaffs_strnlen(newname,YAFFS_MAX_NAME_LENGTH+1);
-               
-               if(new_nameLength == 0){
-                       yaffsfs_SetError(-ENOENT);
-                       retVal = -1;
-               } else if (new_nameLength > YAFFS_MAX_NAME_LENGTH){
-                       yaffsfs_SetError(-ENAMETOOLONG);
-                       retVal = -1;
-               }
+               retVal = yaffsfs_CheckNameLength(newname);
                
                if(retVal == 0) {
                        link = yaffs_link_obj(newdir,newname,obj);
@@ -2371,6 +2372,13 @@ int yaffs_get_error(void)
        return yaffsfs_GetLastError();
 }
 
+int yaffs_set_error(int error)
+{
+       /*yaffsfs_SetError does not return. So the program is assumed to have worked. */
+       yaffsfs_SetError(error);
+       return 0;
+}
+
 int yaffs_dump_dev(const YCHAR *path)
 {
 #if 0