yaffs Yet more tests for quick tests.
[yaffs2.git] / direct / yaffsfs.c
index b187142..41d37f4 100644 (file)
@@ -67,14 +67,14 @@ static yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
 static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
 static int yaffsfs_handlesInitialised;
 
 static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
 static int yaffsfs_handlesInitialised;
 
-unsigned int yaffs_trace_mask;
 
 
-int yaffs_set_trace(unsigned int tm) 
+unsigned yaffs_set_trace(unsigned  tm) 
 {
 {
-       return yaffs_trace_mask=tm;
+       yaffs_trace_mask = tm;
+       return yaffs_trace_mask;
 }
 
 }
 
-unsigned int yaffs_get_trace(void)
+unsigned yaffs_get_trace(void)
 {
        return yaffs_trace_mask;
 }
 {
        return yaffs_trace_mask;
 }
@@ -277,7 +277,7 @@ static int yaffsfs_PutHandle(int handle)
 
 
 /*
 
 
 /*
- *  Stuff to search for a directory from a path
+ *  Stuff to handle names.
  */
 
 
  */
 
 
@@ -300,7 +300,22 @@ int yaffsfs_IsPathDivider(YCHAR ch)
        return 0;
 }
 
        return 0;
 }
 
+int yaffsfs_CheckNameLength(const char *name)
+{
+       int retVal = 0;         
+
+       int nameLength = yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH+1);
+               
+       if(nameLength == 0){
+               yaffsfs_SetError(-ENOENT);
+               retVal = -1;
+       } else if (nameLength > YAFFS_MAX_NAME_LENGTH){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               retVal = -1;
+       }
 
 
+       return retVal;  
+}
 
 LIST_HEAD(yaffsfs_deviceList);
 
 
 LIST_HEAD(yaffsfs_deviceList);
 
@@ -382,48 +397,6 @@ static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPat
        return retval;
 }
 
        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)
 {
 
 static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
 {
@@ -641,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;
 
                        obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
                        obj = NULL;
 
+
                if(obj){
 
                        /* The file already exists or it might be a directory */
                if(obj){
 
                        /* The file already exists or it might be a directory */
@@ -655,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
                         */
                        /* 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;
                                openDenied = 1;
                                yaffsfs_SetError(-EEXIST);
                                errorReported = 1;
@@ -668,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( 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. */
                        /* Check sharing of an existing object. */
-                       {
+                       if(!openDenied){
                                yaffsfs_Handle *hx;
                                int i;
                                sharedReadAllowed = 1;
                                yaffsfs_Handle *hx;
                                int i;
                                sharedReadAllowed = 1;
@@ -704,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);
                        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;
                                yaffsfs_SetError(-EINVAL);
                                errorReported = 1;
-                       } else if(dir)
+                       } else
                                obj = yaffs_create_file(dir,name,mode,0,0);
                                obj = yaffs_create_file(dir,name,mode,0,0);
-                       else {
-                               yaffsfs_SetError(-ENOTDIR);
+
+                       if(!obj && !errorReported){
+                               yaffsfs_SetError(-ENOSPC);
                                errorReported = 1;
                        }
                }
 
                                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);
 
                if(obj && !openDenied) {
                        int inodeId = yaffsfs_GetInodeIdForObject(obj);
 
@@ -743,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);
                                 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;
                }
        }
                        handle = -1;
                }
        }
@@ -1024,13 +1021,14 @@ int yaffs_truncate(const YCHAR *path,off_t new_size)
        else if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE)
                yaffsfs_SetError(-EISDIR);
        else if(obj->my_dev->read_only)
        else if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE)
                yaffsfs_SetError(-EISDIR);
        else if(obj->my_dev->read_only)
+               yaffsfs_SetError(-EACCES);
+       else if(new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)
                yaffsfs_SetError(-EINVAL);
        else
                result = yaffs_resize_file(obj,new_size);
 
        yaffsfs_Unlock();
 
                yaffsfs_SetError(-EINVAL);
        else
                result = yaffs_resize_file(obj,new_size);
 
        yaffsfs_Unlock();
 
-
        return (result) ? 0 : -1;
 }
 
        return (result) ? 0 : -1;
 }
 
@@ -1048,13 +1046,14 @@ int yaffs_ftruncate(int fd, off_t new_size)
                /* bad handle */
                yaffsfs_SetError(-EBADF);
        else if(obj->my_dev->read_only)
                /* bad handle */
                yaffsfs_SetError(-EBADF);
        else if(obj->my_dev->read_only)
+               yaffsfs_SetError(-EACCES);
+       else if( new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)
                yaffsfs_SetError(-EINVAL);
        else
                /* resize the file */
                result = yaffs_resize_file(obj,new_size);
        yaffsfs_Unlock();
 
                yaffsfs_SetError(-EINVAL);
        else
                /* resize the file */
                result = yaffs_resize_file(obj,new_size);
        yaffsfs_Unlock();
 
-
        return (result) ? 0 : -1;
 
 }
        return (result) ? 0 : -1;
 
 }
@@ -1168,8 +1167,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
                yaffsfs_SetError(-EINVAL);
                rename_allowed = 0;
        } else if(olddir->my_dev != newdir->my_dev) {
                yaffsfs_SetError(-EINVAL);
                rename_allowed = 0;
        } else if(olddir->my_dev != newdir->my_dev) {
-               /* oops must be on same device */
-               /* todo error */
+               /* Rename must be on same device */
                yaffsfs_SetError(-EXDEV);
                rename_allowed = 0;
        } else if(obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
                yaffsfs_SetError(-EXDEV);
                rename_allowed = 0;
        } else if(obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
@@ -1658,6 +1656,11 @@ int yaffs_access(const YCHAR *path, int amode)
 
        int retval = 0;
 
 
        int retval = 0;
 
+       if(amode & ~(R_OK | W_OK | X_OK)){
+               yaffsfs_SetError(-EINVAL);
+               return -1;
+       }
+
        yaffsfs_Lock();
 
        obj = yaffsfs_FindObject(NULL,path,0,1);
        yaffsfs_Lock();
 
        obj = yaffsfs_FindObject(NULL,path,0,1);
@@ -1820,7 +1823,7 @@ int yaffs_mount2(const YCHAR *path,int read_only)
        struct yaffs_dev *dev=NULL;
        YCHAR *dummy;
 
        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();
 
 
        yaffsfs_Lock();
 
@@ -2272,7 +2275,6 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
        struct yaffs_obj *obj = NULL;
        int retVal;
 
        struct yaffs_obj *obj = NULL;
        int retVal;
 
-
        yaffsfs_Lock();
 
        obj = yaffsfs_FindObject(NULL,path,0,1);
        yaffsfs_Lock();
 
        obj = yaffsfs_FindObject(NULL,path,0,1);
@@ -2299,8 +2301,6 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
        struct yaffs_obj *obj = NULL;
        struct yaffs_obj *target = NULL;
        int retVal = 0;
        struct yaffs_obj *obj = NULL;
        struct yaffs_obj *target = NULL;
        int retVal = 0;
-       int new_nameLength = 0;
-
 
        yaffsfs_Lock();
 
 
        yaffsfs_Lock();
 
@@ -2332,15 +2332,7 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
                        retVal = -1;
                }
                
                        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);
                
                if(retVal == 0) {
                        link = yaffs_link_obj(newdir,newname,obj);
@@ -2383,6 +2375,13 @@ int yaffs_get_error(void)
        return yaffsfs_GetLastError();
 }
 
        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
 int yaffs_dump_dev(const YCHAR *path)
 {
 #if 0