yaffs direct: Fix more error handling
[yaffs2.git] / direct / yaffsfs.c
index 5c583b9..5194dd4 100644 (file)
 #define YAFFSFS_RW_SIZE  (1<<YAFFSFS_RW_SHIFT)
 
 /* Some forward references */
-static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory, const YCHAR *path, int symDepth, int getEquiv);
+static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory,
+                       const YCHAR *path,
+                       int symDepth, int getEquiv,
+                       struct yaffs_obj **dirOut,
+                       int *notDir, int *loop);
+
 static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj);
 
 unsigned int yaffs_wr_attempts;
@@ -67,6 +72,18 @@ static yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
 static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
 static int yaffsfs_handlesInitialised;
 
+
+unsigned yaffs_set_trace(unsigned  tm) 
+{
+       yaffs_trace_mask = tm;
+       return yaffs_trace_mask;
+}
+
+unsigned yaffs_get_trace(void)
+{
+       return yaffs_trace_mask;
+}
+
 /*
  * yaffsfs_InitHandle
  * Inilitalise handle management on start-up.
@@ -195,8 +212,10 @@ static void yaffsfs_PutInode(int inodeId)
        if(inodeId >= 0 && inodeId < YAFFSFS_N_HANDLES){
                yaffsfs_Inode *in = & yaffsfs_inode[inodeId];
                in->count--;
-               if(in->count <= 0)
+               if(in->count <= 0){
                        yaffsfs_ReleaseInode(in);
+                       in->count = 0;
+               }
        }       
 }
 
@@ -261,11 +280,27 @@ static int yaffsfs_PutHandle(int handle)
        return 0;
 }
 
+static void yaffsfs_BreakDeviceHandles(struct yaffs_dev *dev)
+{
+       yaffsfs_Handle *h;
+       struct yaffs_obj *obj;
+       int i;
+       for(i = 0; i < YAFFSFS_N_HANDLES; i++){
+               h = yaffsfs_GetHandlePointer(i);
+               obj = yaffsfs_GetHandleObject(i);
+               if(h && h->useCount>0 && obj && obj->my_dev == dev){
+                       h->useCount = 0;
+                       yaffsfs_PutInode(h->inodeId);
+                       h->inodeId = -1;
+               }
+       }
+}
+
 
 
 
 /*
- *  Stuff to search for a directory from a path
+ *  Stuff to handle names.
  */
 
 
@@ -288,6 +323,57 @@ int yaffsfs_IsPathDivider(YCHAR ch)
        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;  
+}
+
+
+static int yaffsfs_alt_dir_path(const YCHAR *path, YCHAR **ret_path)
+{
+       YCHAR *alt_path = NULL;
+       int path_length;
+       int i;
+
+       /*
+        * We don't have a definition for max path length.
+        * We will use 3 * max name length instead.
+        */
+       *ret_path = NULL;
+       path_length = 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.
+        * eg. /foo/new_dir/ -> /foo/newdir
+        * Curveball: Need to handle multiple path dividers:
+        * eg. /foof/sdfse///// -> /foo/sdfse
+        */
+       if(path_length > 0 && 
+               yaffsfs_IsPathDivider(path[path_length-1])){
+               alt_path = YMALLOC(path_length + 1);
+               if(!alt_path)
+                       return -1;
+               strcpy(alt_path, path);
+               for(i = path_length-1;
+                       i >= 0 && yaffsfs_IsPathDivider(alt_path[i]);
+                       i--)
+                       alt_path[i] = (YCHAR) 0;
+       }
+       *ret_path = alt_path;
+       return 0;
+}
 
 
 LIST_HEAD(yaffsfs_deviceList);
@@ -295,7 +381,7 @@ LIST_HEAD(yaffsfs_deviceList);
 /*
  * yaffsfs_FindDevice
  * yaffsfs_FindRoot
- * Scan the configuration list to find the root.
+ * Scan the configuration list to find the device
  * Curveballs: Should match paths that end in '/' too
  * Curveball2 Might have "/x/ and "/x/y". Need to return the longest match
  */
@@ -370,48 +456,32 @@ 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)
+static int yaffsfs_CheckPath(const YCHAR *path)
 {
-       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++;
+       int n=0;
+       int divs=0;
+       while(*path && n < YAFFS_MAX_NAME_LENGTH && divs < 100){
+               if(yaffsfs_IsPathDivider(*path)){
+                       n=0;
+                       divs++;
+               } else
+                       n++;
+               path++;
        }
-       return retval;
+       
+       return (*path) ? -1 : 0;
+}
+
+/* FindMountPoint only returns a dev entry if the path is a mount point */
+static struct yaffs_dev *yaffsfs_FindMountPoint(const YCHAR *path)
+{
+       struct yaffs_dev *dev;
+       YCHAR *restOfPath=NULL;
+       dev = yaffsfs_FindDevice(path,&restOfPath);
+       if(dev && restOfPath && *restOfPath)
+               dev = NULL;
+       return dev;
 }
-#endif
 
 static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
 {
@@ -425,7 +495,8 @@ static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
        return NULL;
 }
 
-static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,int symDepth)
+static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,
+                                       int symDepth, int *loop)
 {
 
        if(obj)
@@ -436,10 +507,12 @@ static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,int symDepth)
 
                if(yaffsfs_IsPathDivider(*alias))
                        /* Starts with a /, need to scan from root up */
-                       obj = yaffsfs_FindObject(NULL,alias,symDepth++,1);
+                       obj = yaffsfs_FindObject(NULL,alias,symDepth++,
+                                               1,NULL,NULL,loop);
                else
                        /* Relative to here, so use the parent of the symlink as a start */
-                       obj = yaffsfs_FindObject(obj->parent,alias,symDepth++,1);
+                       obj = yaffsfs_FindObject(obj->parent,alias,symDepth++,
+                                               1,NULL,NULL,loop);
        }
        return obj;
 }
@@ -452,15 +525,19 @@ static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,int symDepth)
  * eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx"
  */
 static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,
-                               const YCHAR *path, YCHAR **name, int symDepth)
+                               const YCHAR *path, YCHAR **name, int symDepth,
+                               int *notDir,int *loop)
 {
        struct yaffs_obj *dir;
        YCHAR *restOfPath;
        YCHAR str[YAFFS_MAX_NAME_LENGTH+1];
        int i;
 
-       if(symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES)
+       if(symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES){
+               if(loop)
+                       *loop = 1;
                return NULL;
+       }
 
        if(startDir){
                dir = startDir;
@@ -469,6 +546,7 @@ static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,
        else
                dir = yaffsfs_FindRoot(path,&restOfPath);
 
+
        while(dir){
                /*
                 * parse off /.
@@ -503,10 +581,15 @@ static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,
                        else{
                                dir = yaffs_find_by_name(dir,str);
 
-                               dir = yaffsfs_FollowLink(dir,symDepth);
+                               dir = yaffsfs_FollowLink(dir,symDepth,loop);
 
-                               if(dir && dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+                               if(dir && dir->variant_type != 
+                                       YAFFS_OBJECT_TYPE_DIRECTORY){
+                                       if(notDir)
+                                               *notDir = 1;
                                        dir = NULL;
+                               }
+                               
                        }
                }
        }
@@ -514,22 +597,31 @@ static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,
        return NULL;
 }
 
-static struct yaffs_obj *yaffsfs_FindDirectory(struct yaffs_obj *relativeDirectory,
-                                       const YCHAR *path,YCHAR **name,int symDepth)
+static struct yaffs_obj *yaffsfs_FindDirectory(struct yaffs_obj *relDir,
+                                       const YCHAR *path,
+                                       YCHAR **name,
+                                       int symDepth,
+                                       int *notDir,
+                                       int *loop)
 {
-       return yaffsfs_DoFindDirectory(relativeDirectory,path,name,symDepth);
+       return yaffsfs_DoFindDirectory(relDir,path,name,symDepth,notDir,loop);
 }
 
 /*
  * yaffsfs_FindObject turns a path for an existing object into the object
  */
-static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory, const YCHAR *path,int symDepth, int getEquiv)
+static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relDir,
+                       const YCHAR *path,int symDepth, int getEquiv,
+                       struct yaffs_obj **dirOut, int *notDir,int *loop)
 {
        struct yaffs_obj *dir;
        struct yaffs_obj *obj;
        YCHAR *name;
 
-       dir = yaffsfs_FindDirectory(relativeDirectory,path,&name,symDepth);
+       dir = yaffsfs_FindDirectory(relDir,path,&name,symDepth,notDir,loop);
+
+       if(dirOut)
+               *dirOut =  dir;
 
        if(dir && *name)
                obj = yaffs_find_by_name(dir,name);
@@ -592,6 +684,13 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
        u8 alreadyWriting;
        u8 readRequested;
        u8 writeRequested;
+       int notDir = 0;
+       int loop = 0;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
 
        /* O_EXCL only has meaning if O_CREAT is specified */
        if(!(oflag & O_CREAT))
@@ -620,15 +719,16 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                yh = yaffsfs_GetHandlePointer(handle);
 
                /* try to find the exisiting object */
-               obj = yaffsfs_FindObject(NULL,path,0,1);
+               obj = yaffsfs_FindObject(NULL,path,0,1,NULL,NULL,NULL);
 
-               obj = yaffsfs_FollowLink(obj,symDepth++);
+               obj = yaffsfs_FollowLink(obj,symDepth++,&loop);
 
                if(obj &&
                        obj->variant_type != YAFFS_OBJECT_TYPE_FILE &&
                        obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
                        obj = NULL;
 
+
                if(obj){
 
                        /* The file already exists or it might be a directory */
@@ -643,7 +743,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 +756,21 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
                        if( writeRequested && !(obj->yst_mode & S_IWRITE))
                                openDenied = 1;
 
+                       if( !errorReported && writeRequested && 
+                               obj->my_dev->read_only){
+                               openDenied = 1;
+                               yaffsfs_SetError(-EROFS);
+                               errorReported = 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 +805,45 @@ 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 */
-                       dir = yaffsfs_FindDirectory(NULL,path,&name,0);
-                       if(dir  && dir->my_dev->read_only){
-                               yaffsfs_SetError(-EINVAL);
+               }
+
+               /* 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,&notDir,&loop);
+                       if(!dir && notDir){
+                               yaffsfs_SetError(-ENOTDIR);
+                               errorReported = 1;
+                       } else if(loop){
+                               yaffsfs_SetError(-ELOOP);
+                               errorReported = 1;
+                       } else  if(!dir){
+                               yaffsfs_SetError(-ENOENT);
                                errorReported = 1;
-                       } else if(dir)
+                       }
+               }
+
+               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(-EROFS);
+                               errorReported = 1;
+                       } 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 +869,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;
                }
        }
@@ -752,19 +888,23 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
 int yaffs_Dofsync(int fd,int datasync)
 {
        yaffsfs_Handle *h = NULL;
-       int retVal = 0;
+       int retVal = -1;
 
        yaffsfs_Lock();
 
        h = yaffsfs_GetHandlePointer(fd);
 
-       if(h && h->useCount > 0)
-               /* flush the file */
-               yaffs_flush_file(yaffsfs_inode[h->inodeId].iObj,1,datasync);
-       else {
-               /* bad handle */
+       if(!h || h->useCount < 1)
                yaffsfs_SetError(-EBADF);
-               retVal = -1;
+       else {
+               struct yaffs_obj * obj;
+               obj = yaffsfs_inode[h->inodeId].iObj;
+               if(obj->my_dev->read_only)
+                       yaffsfs_SetError(-EROFS);
+               else {          
+                       yaffs_flush_file(yaffsfs_inode[h->inodeId].iObj,1,datasync);
+                       retVal = 0;
+               }
        }
 
        yaffsfs_Unlock();
@@ -820,6 +960,7 @@ int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int off
        struct yaffs_obj *obj = NULL;
        int pos = 0;
        int startPos = 0;
+       int endPos = 0;
        int nRead = 0;
        int nToRead = 0;
        int totalRead = 0;
@@ -838,6 +979,9 @@ int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int off
                /* Not a reading handle */
                yaffsfs_SetError(-EINVAL);
                totalRead = -1;
+       } else if(nbyte > YAFFS_MAX_FILE_SIZE){
+               yaffsfs_SetError(-EINVAL);
+               totalRead = -1;
        } else {
                if(isPread)
                        startPos = offset;
@@ -857,11 +1001,29 @@ int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int off
 
                yaffsfs_GetHandle(fd);
 
+               endPos = pos + nbyte;
+
+               if(pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
+                       nbyte > YAFFS_MAX_FILE_SIZE ||
+                       endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE){
+                       totalRead = -1;
+                       nbyte = 0;
+               }
+
                while(nbyte > 0) {
                        nToRead = YAFFSFS_RW_SIZE - (pos & (YAFFSFS_RW_SIZE -1));
                        if(nToRead > nbyte)
                                nToRead = nbyte;
-                       nRead = yaffs_file_rd(obj,buf,pos,nToRead);
+
+                       /* Tricky bit... 
+                        * Need to reverify object in case the device was
+                        * unmounted in another thread.
+                        */
+                       obj = yaffsfs_GetHandleObject(fd);
+                       if(!obj)
+                               nRead = 0;
+                       else
+                               nRead = yaffs_file_rd(obj,buf,pos,nToRead);
 
                        if(nRead > 0){
                                totalRead += nRead;
@@ -887,9 +1049,8 @@ int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int off
                if(!isPread) {
                        if(totalRead >= 0)
                                h->position = startPos + totalRead;
-                       else {
-                                       /* todo error */
-                       }
+                       else
+                               yaffsfs_SetError(-EINVAL);
                }
 
        }
@@ -916,6 +1077,7 @@ int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite,
        struct yaffs_obj *obj = NULL;
        int pos = 0;
        int startPos = 0;
+       int endPos;
        int nWritten = 0;
        int totalWritten = 0;
        int write_trhrough = 0;
@@ -930,9 +1092,12 @@ int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite,
                /* bad handle */
                yaffsfs_SetError(-EBADF);
                totalWritten = -1;
-       } else if( h && obj && (!h->writing || obj->my_dev->read_only)){
+       } else if(!h->writing){
                yaffsfs_SetError(-EINVAL);
                totalWritten=-1;
+       } else if(obj->my_dev->read_only){
+               yaffsfs_SetError(-EROFS);
+               totalWritten=-1;
        } else {
                if(h->append)
                        startPos = yaffs_get_obj_length(obj);
@@ -943,12 +1108,31 @@ int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite,
 
                yaffsfs_GetHandle(fd);
                pos = startPos;
+               endPos = pos + nbyte;
+
+               if(pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
+                       nbyte > YAFFS_MAX_FILE_SIZE ||
+                       endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE){
+                       totalWritten = -1;
+                       nbyte = 0;
+               }
+
                while(nbyte > 0) {
+
                        nToWrite = YAFFSFS_RW_SIZE - (pos & (YAFFSFS_RW_SIZE -1));
                        if(nToWrite > nbyte)
                                nToWrite = nbyte;
 
-                       nWritten = yaffs_wr_file(obj,buf,pos,nToWrite,write_trhrough);
+                       /* Tricky bit... 
+                        * Need to reverify object in case the device was
+                        * remounted or unmounted in another thread.
+                        */
+                       obj = yaffsfs_GetHandleObject(fd);
+                       if(!obj || obj->my_dev->read_only)
+                               nWritten = 0;
+                       else
+                               nWritten = yaffs_wr_file(obj,buf,pos,nToWrite,
+                                                       write_trhrough);
                        if(nWritten > 0){
                                totalWritten += nWritten;
                                pos += nWritten;
@@ -976,9 +1160,8 @@ int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite,
                if(!isPwrite){
                        if(totalWritten > 0)
                                h->position = startPos + totalWritten;
-                       else {
-                               /* todo error */
-                       }
+                       else
+                               yaffsfs_SetError(-EINVAL);
                }
        }
 
@@ -1001,24 +1184,40 @@ int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, unsigned int offse
 int yaffs_truncate(const YCHAR *path,off_t new_size)
 {
        struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *dir = NULL;
        int result = YAFFS_FAIL;
+       int notDir = 0;
+       int loop = 0;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1);
+       obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
+       obj = yaffsfs_FollowLink(obj,0,&loop);
 
-       if(!obj)
+       if(!dir && notDir)
+               yaffsfs_SetError(-ENOTDIR);
+       else if(loop)
+               yaffsfs_SetError(-ELOOP);
+       else if(!dir || !obj)
                yaffsfs_SetError(-ENOENT);
+       else if(obj->my_dev->read_only)
+               yaffsfs_SetError(-EROFS);
        else if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE)
                yaffsfs_SetError(-EISDIR);
        else if(obj->my_dev->read_only)
+               yaffsfs_SetError(-EROFS);
+       else if(new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)
                yaffsfs_SetError(-EINVAL);
        else
                result = yaffs_resize_file(obj,new_size);
 
        yaffsfs_Unlock();
 
-
        return (result) ? 0 : -1;
 }
 
@@ -1035,14 +1234,17 @@ int yaffs_ftruncate(int fd, off_t new_size)
        if(!h || !obj)
                /* bad handle */
                yaffsfs_SetError(-EBADF);
+       else if(!h->writing)
+               yaffsfs_SetError(-EINVAL);
        else if(obj->my_dev->read_only)
+               yaffsfs_SetError(-EROFS);
+       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();
 
-
        return (result) ? 0 : -1;
 
 }
@@ -1058,10 +1260,11 @@ off_t yaffs_lseek(int fd, off_t offset, int whence)
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
 
-       if(!h || !obj){
-               /* bad handle */
+       if(!h || !obj)
                yaffsfs_SetError(-EBADF);
-       } else {
+       else if(offset > YAFFS_MAX_FILE_SIZE)
+               yaffsfs_SetError(-EINVAL);
+       else {
                if(whence == SEEK_SET){
                        if(offset >= 0)
                                pos = offset;
@@ -1074,10 +1277,12 @@ off_t yaffs_lseek(int fd, off_t offset, int whence)
                                pos = fSize + offset;
                } 
 
-               if(pos >= 0)
+               if(pos >= 0 && pos <= YAFFS_MAX_FILE_SIZE)
                        h->position = pos;
-               else
+               else{
                        yaffsfs_SetError(-EINVAL);
+                       pos = -1;
+               }
        }
 
        yaffsfs_Unlock();
@@ -1092,21 +1297,37 @@ int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
        struct yaffs_obj *obj = NULL;
        YCHAR *name;
        int result = YAFFS_FAIL;
+       int notDir = 0;
+       int loop = 0;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,0);
-       dir = yaffsfs_FindDirectory(NULL,path,&name,0);
-       if(!dir)
+       obj = yaffsfs_FindObject(NULL,path,0,0,NULL,NULL,NULL);
+       dir = yaffsfs_FindDirectory(NULL,path,&name,0,&notDir,&loop);
+
+       if(!dir && notDir)
                yaffsfs_SetError(-ENOTDIR);
+       else if(loop)
+               yaffsfs_SetError(-ELOOP);
+       else if(!dir)
+               yaffsfs_SetError(-ENOENT);
+       else if(yaffs_strncmp(name,_Y("."),2) == 0)
+               yaffsfs_SetError(-EINVAL);
        else if(!obj)
                yaffsfs_SetError(-ENOENT);
        else if(obj->my_dev->read_only)
-               yaffsfs_SetError(-EINVAL);
+               yaffsfs_SetError(-EROFS);
        else if(!isDirectory && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
                yaffsfs_SetError(-EISDIR);
        else if(isDirectory && obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
                yaffsfs_SetError(-ENOTDIR);
+       else if(isDirectory && obj == obj->my_dev->root_dir)
+               yaffsfs_SetError(-EBUSY); /* Can't rmdir a root */
        else {
                result = yaffs_unlinker(dir,name);
 
@@ -1116,17 +1337,10 @@ int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
 
        yaffsfs_Unlock();
 
-       /* todo error */
-
        return (result == YAFFS_FAIL) ? -1 : 0;
 }
 
 
-int yaffs_rmdir(const YCHAR *path)
-{
-       return yaffsfs_DoUnlink(path,1);
-}
-
 int yaffs_unlink(const YCHAR *path)
 {
        return yaffsfs_DoUnlink(path,0);
@@ -1137,34 +1351,75 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
        struct yaffs_obj *olddir = NULL;
        struct yaffs_obj *newdir = NULL;
        struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *newobj = NULL;
        YCHAR *oldname;
        YCHAR *newname;
        int result= YAFFS_FAIL;
        int rename_allowed = 1;
+       int notOldDir = 0;
+       int notNewDir = 0;
+       int oldLoop = 0;
+       int newLoop = 0;
+
+       YCHAR *alt_newpath=NULL;
+
+       if(yaffsfs_CheckPath(newPath) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
+       if(yaffsfs_alt_dir_path(newPath, &alt_newpath) < 0){
+               yaffsfs_SetError(-ENOMEM);
+               return -1;
+       }
+       if(alt_newpath)
+               newPath = alt_newpath;
 
        yaffsfs_Lock();
 
-       olddir = yaffsfs_FindDirectory(NULL,oldPath,&oldname,0);
-       newdir = yaffsfs_FindDirectory(NULL,newPath,&newname,0);
-       obj = yaffsfs_FindObject(NULL,oldPath,0,0);
 
-       if(!olddir || !newdir || !obj) {
-               /* bad file */
-               yaffsfs_SetError(-EBADF);
+       olddir = yaffsfs_FindDirectory(NULL,oldPath,&oldname,0,&notOldDir,&oldLoop);
+       newdir = yaffsfs_FindDirectory(NULL,newPath,&newname,0,&notNewDir,&newLoop);
+       obj = yaffsfs_FindObject(NULL,oldPath,0,0,NULL,NULL,NULL);
+       newobj = yaffsfs_FindObject(NULL,newPath,0,0,NULL,NULL,NULL);
+
+       /* If the object being renamed is a directory and the 
+        * path ended with a "/" then the olddir == obj.
+        * We pass through NULL for the old name to tell the lower layers
+        * to use olddir as the object.
+        */
+
+       if(olddir == obj)
+               oldname = NULL;
+
+       if((!olddir && notOldDir) || (!newdir && notNewDir)) {
+               yaffsfs_SetError(-ENOTDIR);
                rename_allowed = 0;
-       } else if(obj->my_dev->read_only){
+       } else if(oldLoop || newLoop) {
+               yaffsfs_SetError(-ELOOP);
+               rename_allowed = 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);
+               rename_allowed = 0;
+       } else if(obj->my_dev->read_only){
+               yaffsfs_SetError(-EROFS);
+               rename_allowed = 0;
+       } else if(yaffs_is_non_empty_dir(newobj)){
+               yaffsfs_SetError(-ENOTEMPTY);
+               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) {
                /*
                 * It is a directory, check that it is not being renamed to
                 * being its own decendent.
-                * Do this by tracing from the new directory back to the root, checking for obj
+                * Do this by tracing from the new directory back to the root, 
+                * checking for obj
                 */
 
                struct yaffs_obj *xx = newdir;
@@ -1175,7 +1430,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
                        xx = xx->parent;
                }
                if(!rename_allowed)
-                       yaffsfs_SetError(-EACCES);
+                       yaffsfs_SetError(-EINVAL);
        }
 
        if(rename_allowed)
@@ -1183,6 +1438,9 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 
        yaffsfs_Unlock();
 
+       if(alt_newpath)
+               YFREE(alt_newpath);
+
        return (result == YAFFS_FAIL) ? -1 : 0;
 }
 
@@ -1231,22 +1489,32 @@ static int yaffsfs_DoStat(struct yaffs_obj *obj,struct yaffs_stat *buf)
 
 static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int doLStat)
 {
-       struct yaffs_obj *obj;
-
+       struct yaffs_obj *obj=NULL;
+       struct yaffs_obj *dir=NULL;
        int retVal = -1;
+       int notDir = 0;
+       int loop = 0;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1);
+       obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
 
        if(!doLStat && obj)
-               obj = yaffsfs_FollowLink(obj,0);
+               obj = yaffsfs_FollowLink(obj,0,&loop);
 
-       if(obj)
-               retVal = yaffsfs_DoStat(obj,buf);
-       else
-               /* todo error not found */
+       if(!dir && notDir)
+               yaffsfs_SetError(-ENOTDIR);
+       else if(loop)
+               yaffsfs_SetError(-ELOOP);
+       else if(!dir || !obj)
                yaffsfs_SetError(-ENOENT);
+       else
+               retVal = yaffsfs_DoStat(obj,buf);
 
        yaffsfs_Unlock();
 
@@ -1291,25 +1559,37 @@ int yaffs_fstat(int fd, struct yaffs_stat *buf)
 static int yaffs_do_setxattr(const YCHAR *path, const char *name, const void *data, int size, int flags, int follow)
 {
        struct yaffs_obj *obj;
+       struct yaffs_obj *dir;
+       int notDir = 0;
+       int loop = 0;
 
        int retVal = -1;
 
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1);
+       obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
 
        if(follow)
-               obj = yaffsfs_FollowLink(obj,0);
+               obj = yaffsfs_FollowLink(obj,0,&loop);
 
-       if(obj) {
+       if(!dir && notDir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(loop) 
+               yaffsfs_SetError(-ELOOP);
+       else if(!dir || !obj) 
+               yaffsfs_SetError(-ENOENT);
+       else {
                retVal = yaffs_set_xattrib(obj,name,data,size,flags);
                if(retVal< 0){
                        yaffsfs_SetError(retVal);
                        retVal = -1;
                }
-       } else
-               /* todo error not found */
-               yaffsfs_SetError(-ENOENT);
+       }
 
        yaffsfs_Unlock();
 
@@ -1338,15 +1618,15 @@ int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int fl
        yaffsfs_Lock();
        obj = yaffsfs_GetHandleObject(fd);
 
-       if(obj) {
+       if(!obj) 
+               yaffsfs_SetError(-EBADF);
+       else {
                retVal = yaffs_set_xattrib(obj,name,data,size,flags);
                if(retVal< 0){
                        yaffsfs_SetError(retVal);
                        retVal = -1;
                }
-       } else
-               /* bad handle */
-               yaffsfs_SetError(-EBADF);
+       }
 
        yaffsfs_Unlock();
 
@@ -1356,26 +1636,36 @@ int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int fl
 static int yaffs_do_getxattr(const YCHAR *path, const char *name, void *data, int size, int follow)
 {
        struct yaffs_obj *obj;
-
+       struct yaffs_obj *dir;
        int retVal = -1;
+       int notDir = 0;
+       int loop = 0;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1);
+       obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
 
        if(follow)
-               obj = yaffsfs_FollowLink(obj,0);
+               obj = yaffsfs_FollowLink(obj,0,&loop);
 
-       if(obj) {
+       if(!dir && notDir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(loop) 
+               yaffsfs_SetError(-ELOOP);
+       else if(!dir || !obj) 
+               yaffsfs_SetError(-ENOENT);
+       else {
                retVal = yaffs_get_xattrib(obj,name,data,size);
                if(retVal< 0){
                        yaffsfs_SetError(retVal);
                        retVal = -1;
                }
-       } else
-               /* todo error not found */
-               yaffsfs_SetError(-ENOENT);
-
+       }
        yaffsfs_Unlock();
 
        return retVal;
@@ -1419,26 +1709,37 @@ int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
 
 static int yaffs_do_listxattr(const YCHAR *path, char *data, int size, int follow)
 {
-       struct yaffs_obj *obj;
-
+       struct yaffs_obj *obj=NULL;
+       struct yaffs_obj *dir=NULL;
        int retVal = -1;
+       int notDir = 0;
+       int loop = 0;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1);
+       obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
 
        if(follow)
-               obj = yaffsfs_FollowLink(obj,0);
+               obj = yaffsfs_FollowLink(obj,0,&loop);
 
-       if(obj) {
+       if(!dir && notDir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(loop) 
+               yaffsfs_SetError(-ELOOP);
+       else if(!dir || !obj) 
+               yaffsfs_SetError(-ENOENT);
+       else {
                retVal = yaffs_list_xattrib(obj, data,size);
                if(retVal< 0){
                        yaffsfs_SetError(retVal);
                        retVal = -1;
                }
-       } else
-               /* todo error not found */
-               yaffsfs_SetError(-ENOENT);
+       }
 
        yaffsfs_Unlock();
 
@@ -1482,26 +1783,37 @@ int yaffs_flistxattr(int fd, char *data, int size)
 
 static int yaffs_do_removexattr(const YCHAR *path, const char *name, int follow)
 {
-       struct yaffs_obj *obj;
-
+       struct yaffs_obj *obj=NULL;
+       struct yaffs_obj *dir=NULL;
+       int notDir = 0;
+       int loop = 0;
        int retVal = -1;
 
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1);
+       obj = yaffsfs_FindObject(NULL,path,0,1, &dir,&notDir,&loop);
 
        if(follow)
-               obj = yaffsfs_FollowLink(obj,0);
+               obj = yaffsfs_FollowLink(obj,0,&loop);
 
-       if(obj) {
+       if(!dir && notDir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(loop) 
+               yaffsfs_SetError(-ELOOP);
+       else if(!dir || !obj) 
+               yaffsfs_SetError(-ENOENT);
+       else {
                retVal = yaffs_remove_xattrib(obj,name);
                if(retVal< 0){
                        yaffsfs_SetError(retVal);
                        retVal = -1;
                }
-       } else
-               /* todo error not found */
-               yaffsfs_SetError(-ENOENT);
+       }
 
        yaffsfs_Unlock();
 
@@ -1642,15 +1954,36 @@ static int yaffsfs_DoChMod(struct yaffs_obj *obj,mode_t mode)
 
 int yaffs_access(const YCHAR *path, int amode)
 {
-       struct yaffs_obj *obj;
+       struct yaffs_obj *obj=NULL;
+       struct yaffs_obj *dir=NULL;
+       int notDir = 0;
+       int loop = 0;
+       int retval = -1;
 
-       int retval = 0;
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
+       if(amode & ~(R_OK | W_OK | X_OK)){
+               yaffsfs_SetError(-EINVAL);
+               return -1;
+       }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1);
+       obj = yaffsfs_FindObject(NULL,path,0,1, &dir,&notDir,&loop);
+       obj = yaffsfs_FollowLink(obj,0,&loop);
 
-       if(obj) {
+       if(!dir && notDir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(loop) 
+               yaffsfs_SetError(-ELOOP);
+       else if(!dir || !obj) 
+               yaffsfs_SetError(-ENOENT);
+       else if((amode & W_OK) && obj->my_dev->read_only)
+               yaffsfs_SetError(-EROFS);
+       else{
                int access_ok = 1;
 
                if((amode & R_OK) && !(obj->yst_mode & S_IREAD))
@@ -1660,14 +1993,10 @@ int yaffs_access(const YCHAR *path, int amode)
                if((amode & X_OK) && !(obj->yst_mode & S_IEXEC))
                        access_ok = 0;
 
-               if(!access_ok) {
+               if(!access_ok)
                        yaffsfs_SetError(-EACCES);
-                       retval = -1;
-               }
-       } else {
-               /* todo error not found */
-               yaffsfs_SetError(-ENOENT);
-               retval = -1;
+               else
+                       retval = 0;
        }
 
        yaffsfs_Unlock();
@@ -1679,18 +2008,35 @@ int yaffs_access(const YCHAR *path, int amode)
 
 int yaffs_chmod(const YCHAR *path, mode_t mode)
 {
-       struct yaffs_obj *obj;
-
+       struct yaffs_obj *obj=NULL;
+       struct yaffs_obj *dir=NULL;
        int retVal = -1;
+       int notDir = 0;
+       int loop = 0;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
+       if(mode & ~(0777)){
+               yaffsfs_SetError(-EINVAL);
+               return -1;
+       }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1);
+       obj = yaffsfs_FindObject(NULL,path,0,1, &dir, &notDir,&loop);
+       obj = yaffsfs_FollowLink(obj,0,&loop);
 
-       if(!obj)
+       if(!dir && notDir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(loop) 
+               yaffsfs_SetError(-ELOOP);
+       else if(!dir || !obj) 
                yaffsfs_SetError(-ENOENT);
        else if(obj->my_dev->read_only)
-               yaffsfs_SetError(-EINVAL);
+               yaffsfs_SetError(-EROFS);
        else
                retVal = yaffsfs_DoChMod(obj,mode);
 
@@ -1704,16 +2050,20 @@ int yaffs_chmod(const YCHAR *path, mode_t mode)
 int yaffs_fchmod(int fd, mode_t mode)
 {
        struct yaffs_obj *obj;
-
        int retVal = -1;
 
+       if(mode & ~(0777)){
+               yaffsfs_SetError(-EINVAL);
+               return -1;
+       }
+
        yaffsfs_Lock();
        obj = yaffsfs_GetHandleObject(fd);
 
        if(!obj)
-               yaffsfs_SetError(-ENOENT);
+               yaffsfs_SetError(-EBADF);
        else if(obj->my_dev->read_only)
-               yaffsfs_SetError(-EINVAL);
+               yaffsfs_SetError(-EROFS);
        else
                retVal = yaffsfs_DoChMod(obj,mode);
 
@@ -1722,77 +2072,82 @@ int yaffs_fchmod(int fd, mode_t mode)
        return retVal;
 }
 
-
 int yaffs_mkdir(const YCHAR *path, mode_t mode)
 {
        struct yaffs_obj *parent = NULL;
        struct yaffs_obj *dir = NULL;
        YCHAR *name;
-       YCHAR *use_path = NULL;
-       int path_length = 0;
+       YCHAR *alt_path = NULL;
        int retVal= -1;
-       int i;
-
+       int notDir = 0;
+       int loop = 0;
 
-       /*
-        * We don't have a definition for max path length.
-        * We will use 3 * max name length instead.
-        */
-       
-       path_length = strnlen(path,(YAFFS_MAX_NAME_LENGTH+1)*3 +1);
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
 
-       /* If the last character is a path divider, then we need to
-        * trim it back so that the name look-up works properly.
-        * eg. /foo/new_dir/ -> /foo/newdir
-        * Curveball: Need to handle multiple path dividers:
-        * eg. /foof/sdfse///// -> /foo/sdfse
-        */
-       if(path_length > 0 && 
-               yaffsfs_IsPathDivider(path[path_length-1])){
-               use_path = YMALLOC(path_length + 1);
-               if(!use_path){
-                       yaffsfs_SetError(-ENOMEM);
-                       return -1;
-               }
-               strcpy(use_path, path);
-               for(i = path_length-1;
-                       i >= 0 && yaffsfs_IsPathDivider(use_path[i]);
-                       i--)
-                       use_path[i] = (YCHAR) 0;
-               path = use_path;
+       if(yaffsfs_alt_dir_path(path, &alt_path) < 0){
+               yaffsfs_SetError(-ENOMEM);
+               return -1;
        }
+       if(alt_path)
+               path = alt_path;
        
        yaffsfs_Lock();
-       parent = yaffsfs_FindDirectory(NULL,path,&name,0);
-       if(parent && yaffs_strnlen(name,5) == 0){
+       parent = yaffsfs_FindDirectory(NULL,path,&name,0,&notDir,&loop);
+       if(!parent && notDir)
+               yaffsfs_SetError(-ENOTDIR);
+       else if(loop)
+               yaffsfs_SetError(-ELOOP);
+       else if(!parent)
+               yaffsfs_SetError(-ENOENT);
+       else if(yaffs_strnlen(name,5) == 0){
                /* Trying to make the root itself */
                yaffsfs_SetError(-EEXIST);
-       } else if(parent && parent->my_dev->read_only){
-               yaffsfs_SetError(-EINVAL);
-       } else {
-               if(parent)
-                       dir = yaffs_create_dir(parent,name,mode,0,0);
+       } else if(parent->my_dev->read_only)
+               yaffsfs_SetError(-EROFS);
+       else {
+               dir = yaffs_create_dir(parent,name,mode,0,0);
                if(dir)
                        retVal = 0;
-               else {
-                       if(!parent)
-                               yaffsfs_SetError(-ENOENT); /* missing path */
-                       else if (yaffs_find_by_name(parent,name))
-                               yaffsfs_SetError(-EEXIST); /* the name already exists */
-                       else
-                               yaffsfs_SetError(-ENOSPC); /* just assume no space */
-                       retVal = -1;
-               }
+               else if (yaffs_find_by_name(parent,name))
+                       yaffsfs_SetError(-EEXIST); /* the name already exists */
+               else
+                       yaffsfs_SetError(-ENOSPC); /* just assume no space */
        }
 
        yaffsfs_Unlock();
 
-       if(use_path)
-               YFREE(use_path);
+       if(alt_path)
+               YFREE(alt_path);
 
        return retVal;
 }
 
+int yaffs_rmdir(const YCHAR *path)
+{
+       int result;
+       YCHAR *alt_path;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
+       if(yaffsfs_alt_dir_path(path, &alt_path) < 0){
+               yaffsfs_SetError(-ENOMEM);
+               return -1;
+       }
+       if(alt_path)
+               path = alt_path;
+       result =  yaffsfs_DoUnlink(path,1);
+       if(alt_path)
+               YFREE(alt_path);
+       return result;
+}
+
+
 void * yaffs_getdev(const YCHAR *path)
 {
        struct yaffs_dev *dev=NULL;
@@ -1806,30 +2161,31 @@ int yaffs_mount2(const YCHAR *path,int read_only)
        int retVal=-1;
        int result=YAFFS_FAIL;
        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));
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
 
        yaffsfs_Lock();
 
        yaffsfs_InitHandles();
 
-       dev = yaffsfs_FindDevice(path,&dummy);
+       dev = yaffsfs_FindMountPoint(path);
        if(dev){
                if(!dev->is_mounted){
                        dev->read_only = read_only ? 1 : 0;
                        result = yaffs_guts_initialise(dev);
                        if(result == YAFFS_FAIL)
-                               /* todo error - mount failed */
                                yaffsfs_SetError(-ENOMEM);
                        retVal = result ? 0 : -1;
 
                }
                else
-                       /* todo error - already mounted. */
                        yaffsfs_SetError(-EBUSY);
        } else
-               /* todo error - no device */
                yaffsfs_SetError(-ENODEV);
 
        yaffsfs_Unlock();
@@ -1847,22 +2203,27 @@ int yaffs_sync(const YCHAR *path)
         int retVal=-1;
         struct yaffs_dev *dev=NULL;
         YCHAR *dummy;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
         
         yaffsfs_Lock();
         dev = yaffsfs_FindDevice(path,&dummy);
         if(dev){
-                if(dev->is_mounted){
+                if(!dev->is_mounted)
+                       yaffsfs_SetError(-EINVAL);
+               else if(dev->read_only)
+                       yaffsfs_SetError(-EROFS);
+               else {
                         
                         yaffs_flush_whole_cache(dev);
                         yaffs_checkpoint_save(dev);
                         retVal = 0;
                         
-                } else
-                        /* todo error - not mounted. */
-                        yaffsfs_SetError(-EINVAL);
-                        
+                }      
         }else
-                /* todo error - no device */
                 yaffsfs_SetError(-ENODEV);
 
         yaffsfs_Unlock();
@@ -1874,10 +2235,15 @@ int yaffs_remount(const YCHAR *path, int force, int read_only)
 {
         int retVal=-1;
        struct yaffs_dev *dev=NULL;
-       YCHAR *dummy;
+       yaffsfs_Handle *yh;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
 
        yaffsfs_Lock();
-       dev = yaffsfs_FindDevice(path,&dummy);
+       dev = yaffsfs_FindMountPoint(path);
        if(dev){
                if(dev->is_mounted){
                        int i;
@@ -1886,7 +2252,9 @@ int yaffs_remount(const YCHAR *path, int force, int read_only)
                        yaffs_flush_whole_cache(dev);
 
                        for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse && !force; i++){
-                               if(yaffsfs_handle[i].useCount>0 && yaffsfs_inode[yaffsfs_handle[i].inodeId].iObj->my_dev == dev)
+                               yh = & yaffsfs_handle[i];
+                               if(yh->useCount>0 && 
+                                       yaffsfs_inode[yh->inodeId].iObj->my_dev == dev)
                                        inUse = 1; /* the device is in use, can't unmount */
                        }
 
@@ -1914,10 +2282,14 @@ int yaffs_unmount2(const YCHAR *path, int force)
 {
         int retVal=-1;
        struct yaffs_dev *dev=NULL;
-       YCHAR *dummy;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
 
        yaffsfs_Lock();
-       dev = yaffsfs_FindDevice(path,&dummy);
+       dev = yaffsfs_FindMountPoint(path);
        if(dev){
                if(dev->is_mounted){
                        int i;
@@ -1927,25 +2299,24 @@ int yaffs_unmount2(const YCHAR *path, int force)
                        yaffs_checkpoint_save(dev);
 
                        for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse; i++){
-                               if(yaffsfs_handle[i].useCount > 0 && yaffsfs_inode[yaffsfs_handle[i].inodeId].iObj->my_dev == dev)
+                               if(yaffsfs_handle[i].useCount > 0 && 
+                               yaffsfs_inode[yaffsfs_handle[i].inodeId].iObj->my_dev == dev)
                                        inUse = 1; /* the device is in use, can't unmount */
                        }
 
                        if(!inUse || force){
+                               if(inUse)
+                                       yaffsfs_BreakDeviceHandles(dev);
                                yaffs_deinitialise(dev);
 
                                retVal = 0;
                        } else
-                               /* todo error can't unmount as files are open */
                                yaffsfs_SetError(-EBUSY);
 
                } else
-                       /* todo error - not mounted. */
                        yaffsfs_SetError(-EINVAL);
 
-       }
-       else
-               /* todo error - no device */
+       } else
                yaffsfs_SetError(-ENODEV);
 
        yaffsfs_Unlock();
@@ -1964,6 +2335,11 @@ loff_t yaffs_freespace(const YCHAR *path)
        struct yaffs_dev *dev=NULL;
        YCHAR *dummy;
 
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
        if(dev  && dev->is_mounted){
@@ -1983,10 +2359,16 @@ loff_t yaffs_totalspace(const YCHAR *path)
        struct yaffs_dev *dev=NULL;
        YCHAR *dummy;
 
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
        if(dev  && dev->is_mounted){
-               retVal = (dev->param.end_block - dev->param.start_block + 1) - dev->param.n_reserved_blocks;
+               retVal = (dev->param.end_block - dev->param.start_block + 1) - 
+                       dev->param.n_reserved_blocks;
                retVal *= dev->param.chunks_per_block;
                retVal *= dev->data_bytes_per_chunk;
 
@@ -2003,6 +2385,11 @@ int yaffs_inodecount(const YCHAR *path)
        struct yaffs_dev *dev=NULL;
        YCHAR *dummy;
 
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
        if(dev  && dev->is_mounted) {
@@ -2132,12 +2519,27 @@ yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
        yaffs_DIR *dir = NULL;
        struct yaffs_obj *obj = NULL;
        yaffsfs_DirectorySearchContext *dsc = NULL;
+       int notDir = 0;
+       int loop = 0;
+
+       if(yaffsfs_CheckPath(dirname) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return NULL;
+       }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,dirname,0,1);
+       obj = yaffsfs_FindObject(NULL,dirname,0,1,NULL,&notDir,&loop);
 
-       if(obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
+       if(!obj && notDir)
+               yaffsfs_SetError(-ENOTDIR);
+       else if(loop)
+               yaffsfs_SetError(-ELOOP);
+       else if(!obj)
+               yaffsfs_SetError(-ENOENT);
+       else if(obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+               yaffsfs_SetError(-ENOTDIR);
+       else {
 
                dsc = YMALLOC(sizeof(yaffsfs_DirectorySearchContext));
                dir = (yaffs_DIR *)dsc;
@@ -2231,22 +2633,31 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
        YCHAR *name;
        int retVal= -1;
        int mode = 0; /* ignore for now */
+       int notDir = 0;
+       int loop = 0;
 
+       if(yaffsfs_CheckPath(newpath) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
        yaffsfs_Lock();
-       parent = yaffsfs_FindDirectory(NULL,newpath,&name,0);
-       if(parent && parent->my_dev->read_only)
-               yaffsfs_SetError(-EINVAL);
+       parent = yaffsfs_FindDirectory(NULL,newpath,&name,0,&notDir,&loop);
+       if(!parent && notDir)
+               yaffsfs_SetError(-ENOTDIR);
+       else if(loop)
+               yaffsfs_SetError(-ELOOP);
+       else if( !parent || yaffs_strnlen(name,5) < 1)
+               yaffsfs_SetError(-ENOENT);
+       else if(parent->my_dev->read_only)
+               yaffsfs_SetError(-EROFS);
        else if(parent){
                obj = yaffs_create_symlink(parent,name,mode,0,0,oldpath);
                if(obj)
                        retVal = 0;
-               else{
-                       yaffsfs_SetError(-ENOSPC); /* just assume no space for now */
-                       retVal = -1;
-               }
-       } else {
-               yaffsfs_SetError(-EINVAL);
-               retVal = -1;
+               else if (yaffsfs_FindObject(NULL,newpath,0,0, NULL,NULL,NULL))
+                       yaffsfs_SetError(-EEXIST);
+               else
+                       yaffsfs_SetError(-ENOSPC);
        }
 
        yaffsfs_Unlock();
@@ -2258,20 +2669,24 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 {
        struct yaffs_obj *obj = NULL;
-       int retVal;
-
+       struct yaffs_obj *dir = NULL;
+       int retVal= -1;
+       int notDir = 0;
+       int loop = 0;
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0,1);
+       obj = yaffsfs_FindObject(NULL,path,0,1, &dir,&notDir,&loop);
 
-       if(!obj) {
+       if(!dir && notDir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(loop) 
+               yaffsfs_SetError(-ELOOP);
+       else if(!dir || !obj) 
                yaffsfs_SetError(-ENOENT);
-               retVal = -1;
-       } else if(obj->variant_type != YAFFS_OBJECT_TYPE_SYMLINK) {
+       else if(obj->variant_type != YAFFS_OBJECT_TYPE_SYMLINK)
                yaffsfs_SetError(-EINVAL);
-               retVal = -1;
-       } else {
+       else {
                YCHAR *alias = obj->variant.symlink_variant.alias;
                memset(buf,0,bufsiz);
                yaffs_strncpy(buf,alias,bufsiz - 1);
@@ -2281,64 +2696,54 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
        return retVal;
 }
 
-int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
+int yaffs_link(const YCHAR *oldpath, const YCHAR *linkpath)
 {
        /* Creates a link called newpath to existing oldpath */
        struct yaffs_obj *obj = NULL;
-       struct yaffs_obj *target = NULL;
-       int retVal = 0;
-       int new_nameLength = 0;
+       struct yaffs_obj *lnk = NULL;
+       struct yaffs_obj *obj_dir = NULL;
+       struct yaffs_obj *lnk_dir = NULL;
+       int retVal = -1;
+       int notDirObj = 0;
+       int notDirLnk = 0;
+       int objLoop = 0;
+       int lnkLoop = 0;
+       YCHAR *newname;
 
+       if(yaffsfs_CheckPath(linkpath) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
 
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,oldpath,0,1);
-       target = yaffsfs_FindObject(NULL,newpath,0,0);
+       obj = yaffsfs_FindObject(NULL,oldpath,0,1,&obj_dir,&notDirObj,&objLoop);
+       lnk = yaffsfs_FindObject(NULL,linkpath,0,0,NULL,NULL,NULL);
+       lnk_dir = yaffsfs_FindDirectory(NULL,linkpath,&newname,0,&notDirLnk,&lnkLoop);
 
-       if(!obj) {
+       if((!obj_dir && notDirObj) || (!lnk_dir && notDirLnk))
+               yaffsfs_SetError(-ENOTDIR);
+       else if(objLoop || lnkLoop)
+               yaffsfs_SetError(-ELOOP);
+       else if(!obj_dir || !lnk_dir || !obj)
                yaffsfs_SetError(-ENOENT);
-               retVal = -1;
-       } else if(obj->my_dev->read_only){
-               yaffsfs_SetError(-EINVAL);
-               retVal= -1;
-       } else if(target) {
+       else if(obj->my_dev->read_only)
+               yaffsfs_SetError(-EROFS);
+       else if(lnk)
                yaffsfs_SetError(-EEXIST);
-               retVal = -1;
-       } else {
-               struct yaffs_obj *newdir = NULL;
-               struct yaffs_obj *link = NULL;
-
-               YCHAR *newname;
-
-               newdir = yaffsfs_FindDirectory(NULL,newpath,&newname,0);
-
-               if(!newdir){
-                       yaffsfs_SetError(-ENOTDIR);
-                       retVal = -1;
-               }else if(newdir->my_dev != obj->my_dev){
-                       yaffsfs_SetError(-EXDEV);
-                       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;
-               }
+       else if(lnk_dir->my_dev != obj->my_dev)
+               yaffsfs_SetError(-EXDEV);
+       else {          
+               retVal = yaffsfs_CheckNameLength(newname);
                
                if(retVal == 0) {
-                       link = yaffs_link_obj(newdir,newname,obj);
-                       if(link)
+                       lnk = yaffs_link_obj(lnk_dir,newname,obj);
+                       if(lnk)
                                retVal = 0;
                        else{
                                yaffsfs_SetError(-ENOSPC);
                                retVal = -1;
                        }
-
                }
        }
        yaffsfs_Unlock();
@@ -2348,11 +2753,19 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
 
 int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev)
 {
+       pathname=pathname;
+       mode=mode;
+       dev=dev;
+
+       yaffsfs_SetError(-EINVAL);
        return -1;
 }
 
 
-
+/*
+ * D E B U G   F U N C T I O N S
+ */
 /*
  * yaffs_n_handles()
  * Returns number of handles attached to the object
@@ -2361,9 +2774,17 @@ int yaffs_n_handles(const YCHAR *path)
 {
        struct yaffs_obj *obj;
 
-       obj = yaffsfs_FindObject(NULL,path,0,1);
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
+       obj = yaffsfs_FindObject(NULL,path,0,1,NULL,NULL,NULL);
 
-       return yaffsfs_CountHandles(obj);
+       if(obj)
+               return yaffsfs_CountHandles(obj);
+       else
+               return -1;
 }
 
 int yaffs_get_error(void)
@@ -2371,9 +2792,17 @@ int yaffs_get_error(void)
        return yaffsfs_GetLastError();
 }
 
+int yaffs_set_error(int error)
+{
+       yaffsfs_SetError(error);
+       return 0;
+}
+
 int yaffs_dump_dev(const YCHAR *path)
 {
-#if 0
+#if 1
+       path=path;
+#else
        YCHAR *rest;
 
        struct yaffs_obj *obj = yaffsfs_FindRoot(path,&rest);