yaffs direct: Modify lseek value checking
[yaffs2.git] / direct / yaffsfs.c
index 9109da7..f32808d 100644 (file)
@@ -1,22 +1,23 @@
 /*
- * YAFFS: Yet another FFS. A NAND-flash specific file system.
- * yaffsfs.c  The interface functions for using YAFFS via a "direct" interface.
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
  *
- * Copyright (C) 2002 Aleph One Ltd.
+ * Copyright (C) 2002-2010 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
  *
  * Created by Charles Manning <charles@aleph1.co.uk>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
- *
  */
+
 #include "yaffsfs.h"
 #include "yaffs_guts.h"
 #include "yaffscfg.h"
-#include <string.h> // for memset
 #include "yportenv.h"
+#include "yaffs_trace.h"
+
+#include <string.h> /* for memset */
 
 #define YAFFSFS_MAX_SYMLINK_DEREFERENCES 5
 
 #endif
 
 
-const char *yaffsfs_c_version="$Id: yaffsfs.c,v 1.4 2005-07-03 05:48:11 charles Exp $";
+/* YAFFSFS_RW_SIZE must be a power of 2 */
+#define YAFFSFS_RW_SHIFT (13)
+#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,
+                       struct yaffs_obj **dirOut);
+
+static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj);
+
+unsigned int yaffs_wr_attempts;
+
+/*
+ * Handle management.
+ * There are open inodes in yaffsfs_Inode.
+ * There are open handles in yaffsfs_Handle.
+ *
+ * Things are structured this way to be like the Linux VFS model
+ * so that interactions with the yaffs guts calls are similar.
+ * That means more common code paths and less special code.
+ * That means better testing etc.
+ */
 
-// configurationList is the list of devices that are supported
-static yaffsfs_DeviceConfiguration *yaffsfs_configurationList;
+typedef struct {
+       int count;      /* Number of handles accessing this inode */
+       struct yaffs_obj *iObj;
+} yaffsfs_Inode;
+
+typedef struct{
+       u8      reading:1;
+       u8      writing:1;
+       u8      append:1;
+       u8      shareRead:1;
+       u8      shareWrite:1;
+       int     inodeId:12;     /* Index to corresponding yaffsfs_Inode */
+       int     useCount:10;    /* Use count for this handle */
+       u32 position;           /* current position in file */
+}yaffsfs_Handle;
 
+static yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
+static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
+static int yaffsfs_handlesInitialised;
 
-//
-// Directory search context
-//
-// NB this is an opaque structure.
 
-struct yaffsfs_ObjectListEntry
+unsigned yaffs_set_trace(unsigned  tm) 
 {
-       int objectId;
-       struct yaffsfs_ObjectListEntry *next;
-};
+       yaffs_trace_mask = tm;
+       return yaffs_trace_mask;
+}
 
+unsigned yaffs_get_trace(void)
+{
+       return yaffs_trace_mask;
+}
 
-typedef struct
+/*
+ * yaffsfs_InitHandle
+ * Inilitalise handle management on start-up.
+ */
+
+static void yaffsfs_InitHandles(void)
 {
-       __u32 magic;
-       yaffs_dirent de;
-       struct yaffsfs_ObjectListEntry *list;
-       char name[NAME_MAX+1];
-       
-} yaffsfs_DirectorySearchContext;
+       int i;
+       if(yaffsfs_handlesInitialised)
+                return;
+
+       memset(yaffsfs_inode,0,sizeof(yaffsfs_inode));
+       memset(yaffsfs_handle,0,sizeof(yaffsfs_handle));
+       for(i = 0; i < YAFFSFS_N_HANDLES; i++)
+               yaffsfs_handle[i].inodeId = -1;
+}
 
+yaffsfs_Handle *yaffsfs_GetHandlePointer(int h)
+{
+       if(h < 0 || h >= YAFFSFS_N_HANDLES)
+               return NULL;
 
-// Handle management.
-// 
+       return &yaffsfs_handle[h];
+}
 
-typedef struct
+yaffsfs_Inode *yaffsfs_GetInodePointer(int handle)
 {
-       __u8  inUse:1;          // this handle is in use
-       __u8  readOnly:1;       // this handle is read only
-       __u8  append:1;         // append only
-       __u8  exclusive:1;      // exclusive
-       __u32 position;         // current position in file
-       yaffs_Object *obj;      // the object
-}yaffsfs_Handle;
+       yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
 
+       if(h && h->useCount > 0 && h->inodeId >= 0 && h->inodeId < YAFFSFS_N_HANDLES)
+               return  &yaffsfs_inode[h->inodeId];
 
-static yaffs_Object *yaffsfs_FindObject(yaffs_Object *relativeDirectory, const char *path, int symDepth);
+       return NULL;
+}
 
+struct yaffs_obj *yaffsfs_GetHandleObject(int handle)
+{
+       yaffsfs_Inode *in = yaffsfs_GetInodePointer(handle);
 
+       if(in)
+               return in->iObj;
 
-static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
+       return NULL;
+}
 
-// yaffsfs_InitHandle
-/// Inilitalise handles on start-up.
-//
-static int yaffsfs_InitHandles(void)
+/*
+ * yaffsfs_FindInodeIdForObject
+ * Find the inode entry for an object, if it exists.
+ */
+
+static int yaffsfs_FindInodeIdForObject(struct yaffs_obj *obj)
 {
        int i;
-       for(i = 0; i < YAFFSFS_N_HANDLES; i++)
-       {
-               yaffsfs_handle[i].inUse = 0;
-               yaffsfs_handle[i].obj = NULL;
+       int ret = -1;
+       
+       if(obj)
+               obj = yaffs_get_equivalent_obj(obj);
+
+       /* Look for it in open inode table*/
+       for(i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++){
+               if(yaffsfs_inode[i].iObj == obj)
+                       ret = i;
        }
-       return 0;
+       return ret;
 }
 
-yaffsfs_Handle *yaffsfs_GetHandlePointer(int h)
+/*
+ * yaffsfs_GetInodeIdForObject
+ * Grab an inode entry when opening a new inode.
+ */
+static int yaffsfs_GetInodeIdForObject(struct yaffs_obj *obj)
 {
-       if(h < 0 || h >= YAFFSFS_N_HANDLES)
-       {
-               return NULL;
+       int i;
+       int ret;
+       yaffsfs_Inode *in = NULL;
+       
+       if(obj)
+               obj = yaffs_get_equivalent_obj(obj);
+
+        ret = yaffsfs_FindInodeIdForObject(obj);
+
+       for(i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++){
+               if(!yaffsfs_inode[i].iObj)
+                       ret = i;
+       }
+
+       if(ret>=0){
+               in = &yaffsfs_inode[ret];
+               if(!in->iObj)
+                       in->count = 0;
+               in->iObj = obj;
+               in->count++;
        }
        
-       return &yaffsfs_handle[h];
+       
+       return ret;
 }
 
-yaffs_Object *yaffsfs_GetHandleObject(int handle)
+
+static int yaffsfs_CountHandles(struct yaffs_obj *obj)
 {
-       yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
+       int i = yaffsfs_FindInodeIdForObject(obj);
 
-       if(h && h->inUse)
-       {
-               return h->obj;
-       }
+       if(i >= 0)
+               return yaffsfs_inode[i].count;
+       else
+               return 0;
+}
+
+static void yaffsfs_ReleaseInode(yaffsfs_Inode *in)
+{
+       struct yaffs_obj *obj;
        
-       return NULL;
+       obj = in->iObj;
+
+       if(obj->unlinked)
+               yaffs_del_obj(obj);
+       
+       obj->my_inode = NULL;
+       in->iObj = NULL;
+
+}
+
+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){
+                       yaffsfs_ReleaseInode(in);
+                       in->count = 0;
+               }
+       }       
 }
 
 
-//yaffsfs_GetHandle
-// Grab a handle (when opening a file)
-//
+/*
+ * yaffsfs_GetHandle
+ * Grab a handle (when opening a file)
+ */
 
-static int yaffsfs_GetHandle(void)
+static int yaffsfs_GetNewHandle(void)
 {
        int i;
        yaffsfs_Handle *h;
-       
-       for(i = 0; i < YAFFSFS_N_HANDLES; i++)
-       {
+
+       for(i = 0; i < YAFFSFS_N_HANDLES; i++){
                h = yaffsfs_GetHandlePointer(i);
-               if(!h)
-               {
-                       // todo bug: should never happen
+               if(!h){
+                       /* todo bug: should never happen */
                }
-               if(!h->inUse)
-               {
+               if(h->useCount < 1){
                        memset(h,0,sizeof(yaffsfs_Handle));
-                       h->inUse=1;
+                       h->inodeId=-1;
+                       h->useCount=1;
                        return i;
                }
        }
        return -1;
 }
 
-// yaffs_PutHandle
-// Let go of a handle (when closing a file)
-//
+/*
+ * yaffs_get_handle
+ * Increase use of handle when reading/writing a file
+ */
+static int yaffsfs_GetHandle(int handle)
+{
+       yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
+
+       if(h && h->useCount > 0){       
+               h->useCount++;
+       }
+       return 0;
+}
+
+/*
+ * yaffs_put_handle
+ * Let go of a handle when closing a file or aborting an open or
+ * ending a read or write.
+ */
 static int yaffsfs_PutHandle(int handle)
 {
        yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
-       
-       if(h)
-       {
-               h->inUse = 0;
-               h->obj = NULL;
+
+       if(h && h->useCount > 0){       
+               h->useCount--;
+               if(h->useCount < 1){
+                       if(h->inodeId >= 0){
+                               yaffsfs_PutInode(h->inodeId);
+                               h->inodeId = -1;
+                       }
+               }
        }
        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.
+ */
 
-int yaffsfs_Match(char a, char b)
+
+int yaffsfs_Match(YCHAR a, YCHAR b)
 {
-       // case sensitive
+       /* case sensitive */
        return (a == b);
 }
 
-// yaffsfs_FindDevice
-// yaffsfs_FindRoot
-// Scan the configuration list to find the root.
-static yaffs_Device *yaffsfs_FindDevice(const char *path, char **restOfPath)
+int yaffsfs_IsPathDivider(YCHAR ch)
 {
-       yaffsfs_DeviceConfiguration *cfg = yaffsfs_configurationList;
-       const char *leftOver;
-       const char *p;
-       
-       while(cfg && cfg->prefix && cfg->dev)
-       {
+       const YCHAR *str = YAFFS_PATH_DIVIDERS;
+
+       while(*str){
+               if(*str == ch)
+                       return 1;
+               str++;
+       }
+
+       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);
+
+/*
+ * yaffsfs_FindDevice
+ * yaffsfs_FindRoot
+ * 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
+ */
+static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
+{
+       struct list_head *cfg;
+       const YCHAR *leftOver;
+       const YCHAR *p;
+       struct yaffs_dev *retval = NULL;
+       struct yaffs_dev *dev = NULL;
+       int thisMatchLength;
+       int longestMatch = -1;
+       int matching;
+
+       /*
+        * Check all configs, choose the one that:
+        * 1) Actually matches a prefix (ie /a amd /abc will not match
+        * 2) Matches the longest.
+        */
+       list_for_each(cfg, &yaffsfs_deviceList){
+               dev = list_entry(cfg, struct yaffs_dev, dev_list);
                leftOver = path;
-               p = cfg->prefix;
-               while(*p && *leftOver && yaffsfs_Match(*p,*leftOver))
-               {
-                       p++;
-                       leftOver++;
+               p = dev->param.name;
+               thisMatchLength = 0;
+               matching = 1;
+
+
+               while(matching && *p && *leftOver){
+                       /* Skip over any /s */
+                       while(yaffsfs_IsPathDivider(*p))
+                             p++;
+
+                       /* Skip over any /s */
+                       while(yaffsfs_IsPathDivider(*leftOver))
+                             leftOver++;
+
+                       /* Now match the text part */
+                       while(matching &&
+                             *p && !yaffsfs_IsPathDivider(*p) &&
+                             *leftOver && !yaffsfs_IsPathDivider(*leftOver)){
+                               if(yaffsfs_Match(*p,*leftOver)){
+                                       p++;
+                                       leftOver++;
+                                       thisMatchLength++;
+                               } else {
+                                       matching = 0;
+                               }
+                       }
                }
-               if(!*p && (!*leftOver || *leftOver == '/'))
+
+               /* Skip over any /s in leftOver */
+               while(yaffsfs_IsPathDivider(*leftOver))
+                     leftOver++;
+
+               // Skip over any /s in p
+               while(yaffsfs_IsPathDivider(*p))
+                     p++;
+
+               // p should now be at the end of the string (ie. fully matched)
+               if(*p)
+                       matching = 0;
+
+               if( matching && (thisMatchLength > longestMatch))
                {
                        // Matched prefix
-                       *restOfPath = (char *)leftOver;
-                       return cfg->dev;
+                       *restOfPath = (YCHAR *)leftOver;
+                       retval = dev;
+                       longestMatch = thisMatchLength;
                }
-               cfg++;
+
        }
-       return NULL;
+       return retval;
 }
 
-static yaffs_Object *yaffsfs_FindRoot(const char *path, char **restOfPath)
+static int yaffsfs_CheckPath(const YCHAR *path)
 {
+       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 (*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;
+}
+
+static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
+{
+
+       struct yaffs_dev *dev;
 
-       yaffs_Device *dev;
-       
        dev= yaffsfs_FindDevice(path,restOfPath);
-       if(dev && dev->isMounted)
-       {
-               return dev->rootDir;
+       if(dev && dev->is_mounted){
+               return dev->root_dir;
        }
        return NULL;
 }
 
-static yaffs_Object *yaffsfs_FollowLink(yaffs_Object *obj,int symDepth)
+static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,int symDepth)
 {
 
-       while(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
-       {
-               char *alias = obj->variant.symLinkVariant.alias;
-                                               
-               if(*alias == '/')
-               {
-                       // Starts with a /, need to scan from root up
-                       obj = yaffsfs_FindObject(NULL,alias,symDepth++);
-               }
+       if(obj)
+               obj = yaffs_get_equivalent_obj(obj);
+
+       while(obj && obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK){
+               YCHAR *alias = obj->variant.symlink_variant.alias;
+
+               if(yaffsfs_IsPathDivider(*alias))
+                       /* Starts with a /, need to scan from root up */
+                       obj = yaffsfs_FindObject(NULL,alias,symDepth++,1,NULL);
                else
-               {
-                       // Relative to here, so use the parent of the symlink as a start
-                       obj = yaffsfs_FindObject(obj->parent,alias,symDepth++);
-               }
+                       /* Relative to here, so use the parent of the symlink as a start */
+                       obj = yaffsfs_FindObject(obj->parent,alias,symDepth++,1,NULL);
        }
        return obj;
 }
 
 
-// yaffsfs_FindDirectory
-// Parse a path to determine the directory and the name within the directory.
-//
-// eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx"
-static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const char *path,char **name,int symDepth)
+/*
+ * yaffsfs_FindDirectory
+ * Parse a path to determine the directory and the name within the directory.
+ *
+ * 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)
 {
-       yaffs_Object *dir;
-       char *restOfPath;
-       char str[YAFFS_MAX_NAME_LENGTH+1];
+       struct yaffs_obj *dir;
+       YCHAR *restOfPath;
+       YCHAR str[YAFFS_MAX_NAME_LENGTH+1];
        int i;
-       
+
        if(symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES)
-       {
                return NULL;
-       }
-       
-       if(startDir)
-       {
+
+       if(startDir){
                dir = startDir;
-               restOfPath = (char *)path;
+               restOfPath = (YCHAR *)path;
        }
        else
-       {
                dir = yaffsfs_FindRoot(path,&restOfPath);
-       }
-       
-       while(dir)
-       {       
-               // parse off /.
-               // curve ball: also throw away surplus '/' 
-               // eg. "/ram/x////ff" gets treated the same as "/ram/x/ff"
-               while(*restOfPath == '/')
-               {
-                       restOfPath++; // get rid of '/'
-               }
-               
+
+       while(dir){
+               /*
+                * parse off /.
+                * curve ball: also throw away surplus '/'
+                * eg. "/ram/x////ff" gets treated the same as "/ram/x/ff"
+                */
+               while(yaffsfs_IsPathDivider(*restOfPath))
+                       restOfPath++; /* get rid of '/' */
+
                *name = restOfPath;
                i = 0;
-               
-               while(*restOfPath && *restOfPath != '/')
-               {
-                       if (i < YAFFS_MAX_NAME_LENGTH)
-                       {
+
+               while(*restOfPath && !yaffsfs_IsPathDivider(*restOfPath)){
+                       if (i < YAFFS_MAX_NAME_LENGTH){
                                str[i] = *restOfPath;
                                str[i+1] = '\0';
                                i++;
                        }
                        restOfPath++;
                }
-               
+
                if(!*restOfPath)
-               {
-                       // got to the end of the string
+                       /* got to the end of the string */
                        return dir;
-               }
-               else
-               {
-                       if(strcmp(str,".") == 0)
+               else{
+                       if(yaffs_strcmp(str,_Y(".")) == 0)
                        {
-                               // Do nothing
+                               /* Do nothing */
                        }
-                       else if(strcmp(str,"..") == 0)
-                       {
+                       else if(yaffs_strcmp(str,_Y("..")) == 0)
                                dir = dir->parent;
-                       }
-                       else
-                       {
-                               dir = yaffs_FindObjectByName(dir,str);
-                               
-                               while(dir && dir->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
-                               {
-                               
-                                       dir = yaffsfs_FollowLink(dir,symDepth);
-               
-                               }
-                               
-                               if(dir && dir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
-                               {
+                       else{
+                               dir = yaffs_find_by_name(dir,str);
+
+                               dir = yaffsfs_FollowLink(dir,symDepth);
+
+                               if(dir && dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
                                        dir = NULL;
-                               }
                        }
                }
        }
-       // directory did not exist.
+       /* directory did not exist. */
        return NULL;
 }
 
-static yaffs_Object *yaffsfs_FindDirectory(yaffs_Object *relativeDirectory,const char *path,char **name,int symDepth)
+static struct yaffs_obj *yaffsfs_FindDirectory(struct yaffs_obj *relativeDirectory,
+                                       const YCHAR *path,YCHAR **name,int symDepth)
 {
        return yaffsfs_DoFindDirectory(relativeDirectory,path,name,symDepth);
 }
 
-// yaffsfs_FindObject turns a path for an existing object into the object
-// 
-static yaffs_Object *yaffsfs_FindObject(yaffs_Object *relativeDirectory, const char *path,int symDepth)
+/*
+ * 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,
+                       struct yaffs_obj **dirOut)
 {
-       yaffs_Object *dir;
-       char *name;
-       
+       struct yaffs_obj *dir;
+       struct yaffs_obj *obj;
+       YCHAR *name;
+
        dir = yaffsfs_FindDirectory(relativeDirectory,path,&name,symDepth);
-       
+
+       if(dirOut)
+               *dirOut =  dir;
+
        if(dir && *name)
-       {
-               return yaffs_FindObjectByName(dir,name);
+               obj = yaffs_find_by_name(dir,name);
+       else
+               obj = dir;
+
+       if(getEquiv)
+               obj = yaffs_get_equivalent_obj(obj);
+
+       return obj;
+}
+
+
+int yaffs_dup(int fd)
+{
+       int newHandle = -1;
+       yaffsfs_Handle *oldPtr = NULL;
+       yaffsfs_Handle *newPtr = NULL;
+
+       yaffsfs_Lock();
+
+       oldPtr = yaffsfs_GetHandlePointer(fd);
+       if(oldPtr && oldPtr->useCount > 0)
+               newHandle = yaffsfs_GetNewHandle();
+       if(newHandle >= 0)
+               newPtr = yaffsfs_GetHandlePointer(newHandle);
+
+       if(newPtr){
+               *newPtr = *oldPtr;
+               return newHandle;
        }
-       
-       return dir;
+
+       if(!oldPtr)
+               yaffsfs_SetError(-EBADF);
+       else
+               yaffsfs_SetError(-ENOMEM);
+
+       return -1;
+
 }
 
 
 
-int yaffs_open(const char *path, int oflag, int mode)
+int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 {
-       yaffs_Object *obj = NULL;
-       yaffs_Object *dir = NULL;
-       char *name;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *dir = NULL;
+       YCHAR *name;
        int handle = -1;
-       yaffsfs_Handle *h = NULL;
-       int alreadyOpen = 0;
-       int alreadyExclusive = 0;
+       yaffsfs_Handle *yh = NULL;
        int openDenied = 0;
        int symDepth = 0;
        int errorReported = 0;
-       
-       int i;
-       
-       
-       // todo sanity check oflag (eg. can't have O_TRUNC without WRONLY or RDWR
-       
-       
+       int rwflags = oflag & ( O_RDWR | O_RDONLY | O_WRONLY);
+       u8 shareRead = (sharing & YAFFS_SHARE_READ) ?  1 : 0;
+       u8 shareWrite = (sharing & YAFFS_SHARE_WRITE) ? 1 : 0;
+       u8 sharedReadAllowed;
+       u8 sharedWriteAllowed;
+       u8 alreadyReading;
+       u8 alreadyWriting;
+       u8 readRequested;
+       u8 writeRequested;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
+       /* O_EXCL only has meaning if O_CREAT is specified */
+       if(!(oflag & O_CREAT))
+               oflag &= ~(O_EXCL);
+
+       /* O_TRUNC has no meaning if (O_CREAT | O_EXCL) is specified */
+       if( (oflag & O_CREAT) & (oflag & O_EXCL))
+               oflag &= ~(O_TRUNC);
+
+       /* Todo: Are there any more flag combos to sanitise ? */
+
+       /* Figure out if reading or writing is requested */
+
+       readRequested = (rwflags == O_RDWR || rwflags == O_RDONLY) ? 1 : 0;
+       writeRequested = (rwflags == O_RDWR || rwflags == O_WRONLY) ? 1 : 0;
+
        yaffsfs_Lock();
-       
-       handle = yaffsfs_GetHandle();
-       
-       if(handle >= 0)
-       {
 
-               h = yaffsfs_GetHandlePointer(handle);
-       
-       
-               // try to find the exisiting object
-               obj = yaffsfs_FindObject(NULL,path,0);
-               
-               if(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
-               {
-               
-                       obj = yaffsfs_FollowLink(obj,symDepth++);
-               }
+       handle = yaffsfs_GetNewHandle();
 
-               if(obj)
-               {
-                       // Check if the object is already in use
-                       alreadyOpen = alreadyExclusive = 0;
-                       
-                       for(i = 0; i <= YAFFSFS_N_HANDLES; i++)
-                       {
-                               
-                               if(i != handle &&
-                                  yaffsfs_handle[i].inUse &&
-                                   obj == yaffsfs_handle[i].obj)
-                                {
-                                       alreadyOpen = 1;
-                                       if(yaffsfs_handle[i].exclusive)
-                                       {
-                                               alreadyExclusive = 1;
-                                       }
-                                }
-                       }
+       if(handle < 0){
+               yaffsfs_SetError(-ENFILE);
+               errorReported = 1;
+       } else {
 
-                       if(((oflag & O_EXCL) && alreadyOpen) || alreadyExclusive)
-                       {
+               yh = yaffsfs_GetHandlePointer(handle);
+
+               /* try to find the exisiting object */
+               obj = yaffsfs_FindObject(NULL,path,0,1,NULL);
+
+               obj = yaffsfs_FollowLink(obj,symDepth++);
+
+               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 */
+
+                       /* If it is a directory then we can't open it as a file */
+                       if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
                                openDenied = 1;
+                               yaffsfs_SetError(-EISDIR);
+                               errorReported = 1;
                        }
-                       
-                       // Open should fail if O_CREAT and O_EXCL are specified
-                       if((oflag & O_EXCL) && (oflag & O_CREAT))
-                       {
+
+                       /* Open should fail if O_CREAT and O_EXCL are specified since
+                        * the file exists
+                        */
+                       if(!errorReported && (oflag & O_EXCL) && (oflag & O_CREAT)){
                                openDenied = 1;
                                yaffsfs_SetError(-EEXIST);
                                errorReported = 1;
                        }
-                       
-                       // Check file permissions
-                       if( (oflag & (O_RDWR | O_WRONLY)) == 0 &&     // ie O_RDONLY
-                          !(obj->st_mode & S_IREAD))
-                       {
+
+                       /* Check file permissions */
+                       if( readRequested && !(obj->yst_mode & S_IREAD))
                                openDenied = 1;
-                       }
 
-                       if( (oflag & O_RDWR) && 
-                          !(obj->st_mode & S_IREAD))
-                       {
+                       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;
                        }
 
-                       if( (oflag & (O_RDWR | O_WRONLY)) && 
-                          !(obj->st_mode & S_IWRITE))
-                       {
-                               openDenied = 1;
+                       /* Check sharing of an existing object. */
+                       if(!openDenied){
+                               yaffsfs_Handle *hx;
+                               int i;
+                               sharedReadAllowed = 1;
+                               sharedWriteAllowed = 1;
+                               alreadyReading = 0;
+                               alreadyWriting = 0;
+                               for( i = 0; i < YAFFSFS_N_HANDLES; i++){
+                                       hx = &yaffsfs_handle[i];
+                                       if(hx->useCount > 0 &&
+                                               hx->inodeId >= 0 &&
+                                               yaffsfs_inode[hx->inodeId].iObj == obj){
+                                               if(!hx->shareRead)
+                                                       sharedReadAllowed = 0;
+                                               if(!hx->shareWrite)
+                                                       sharedWriteAllowed = 0;
+                                               if(hx->reading)
+                                                       alreadyReading = 1;
+                                               if(hx->writing)
+                                                       alreadyWriting = 1;
+                                       }
+                               }
+
+
+
+                               if((!sharedReadAllowed && readRequested)|| 
+                                       (!shareRead  && alreadyReading) ||
+                                       (!sharedWriteAllowed && writeRequested) ||
+                                       (!shareWrite && alreadyWriting)){
+                                       openDenied = 1;
+                                       yaffsfs_SetError(-EBUSY);
+                                       errorReported=1;
+                               }
                        }
-                       
+
                }
-               
-               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)
-                       {
-                               obj = yaffs_MknodFile(dir,name,mode,0,0);       
-                       }
-                       else
-                       {
+                       if(!dir){
                                yaffsfs_SetError(-ENOTDIR);
+                               errorReported = 1;
                        }
                }
-               
-               if(obj && !openDenied)
-               {
-                       h->obj = obj;
-                       h->inUse = 1;
-               h->readOnly = (oflag & (O_WRONLY | O_RDWR)) ? 0 : 1;
-                       h->append =  (oflag & O_APPEND) ? 1 : 0;
-                       h->exclusive = (oflag & O_EXCL) ? 1 : 0;
-                       h->position = 0;
-                       
-                       obj->inUse++;
-                       if((oflag & O_TRUNC) && !h->readOnly)
-                       {
-                               //todo truncate
-                               yaffs_ResizeFile(obj,0);
+
+               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
+                               obj = yaffs_create_file(dir,name,mode,0,0);
+
+                       if(!obj && !errorReported){
+                               yaffsfs_SetError(-ENOSPC);
+                               errorReported = 1;
                        }
-                       
                }
-               else
-               {
-                       yaffsfs_PutHandle(handle);
-                       if(!errorReported)
-                       {
-                               yaffsfs_SetError(-EACCESS);
-                               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(inodeId<0) {
+                               /*
+                                * Todo: Fix any problem if inodes run out, though that
+                                * can't happen if the number of inode items >= number of handles. 
+                                */
                        }
+                       
+                       yh->inodeId = inodeId;
+                       yh->reading = readRequested;
+                       yh->writing = writeRequested;
+                       yh->append =  (oflag & O_APPEND) ? 1 : 0;
+                       yh->position = 0;
+                       yh->shareRead = shareRead;
+                       yh->shareWrite = shareWrite;
+
+                       /* Hook inode to object */
+                        obj->my_inode = (void*) &yaffsfs_inode[inodeId];
+
+                        if((oflag & O_TRUNC) && yh->writing)
+                                yaffs_resize_file(obj,0);
+               } else {
+                       yaffsfs_PutHandle(handle);
+                       if(!errorReported) 
+                               yaffsfs_SetError(0); /* Problem */
                        handle = -1;
                }
-               
        }
-       
+
        yaffsfs_Unlock();
-       
-       return handle;          
+
+       return handle;
+}
+
+int yaffs_open(const YCHAR *path, int oflag, int mode)
+{
+       return yaffs_open_sharing(path, oflag, mode, YAFFS_SHARE_READ | YAFFS_SHARE_WRITE);
+}
+
+int yaffs_Dofsync(int fd,int datasync)
+{
+       yaffsfs_Handle *h = NULL;
+       int retVal = 0;
+
+       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 */
+               yaffsfs_SetError(-EBADF);
+               retVal = -1;
+       }
+
+       yaffsfs_Unlock();
+
+       return retVal;
+}
+
+int yaffs_fsync(int fd)
+{
+       return yaffs_Dofsync(fd,0);
+}
+
+int yaffs_flush(int fd)
+{
+       return yaffs_fsync(fd);
+}
+
+int yaffs_fdatasync(int fd)
+{
+       return yaffs_Dofsync(fd,1);
 }
 
 int yaffs_close(int fd)
 {
        yaffsfs_Handle *h = NULL;
        int retVal = 0;
-       
+
        yaffsfs_Lock();
 
        h = yaffsfs_GetHandlePointer(fd);
-       
-       if(h && h->inUse)
-       {
-               // clean up
-               yaffs_FlushFile(h->obj,1);
-               h->obj->inUse--;
-               if(h->obj->inUse <= 0 && h->obj->unlinked)
-               {
-                       yaffs_DeleteFile(h->obj);
-               }
+
+       if(h && h->useCount > 0) {
+               /* clean up */
+               yaffs_flush_file(yaffsfs_inode[h->inodeId].iObj,1,0);
                yaffsfs_PutHandle(fd);
                retVal = 0;
-       }
-       else
-       {
-               // bad handle
-               yaffsfs_SetError(-EBADF);               
+       } else {
+               /* bad handle */
+               yaffsfs_SetError(-EBADF);
                retVal = -1;
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
 }
 
-int yaffs_read(int fd, void *buf, unsigned int nbyte)
+
+
+int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int offset)
 {
        yaffsfs_Handle *h = NULL;
-       yaffs_Object *obj = NULL;
+       struct yaffs_obj *obj = NULL;
        int pos = 0;
-       int nRead = -1;
-       int maxRead;
-       
+       int startPos = 0;
+       int endPos = 0;
+       int nRead = 0;
+       int nToRead = 0;
+       int totalRead = 0;
+       unsigned int maxRead;
+       u8 *buf = (u8 *)vbuf;
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
-       if(!h || !obj)
-       {
-               // bad handle
-               yaffsfs_SetError(-EBADF);               
-       }
-       else if( h && obj)
-       {
-               pos=  h->position;
-               if(yaffs_GetObjectFileLength(obj) > pos)
-               {
-                       maxRead = yaffs_GetObjectFileLength(obj) - pos;
-               }
+
+       if(!h || !obj){
+               /* bad handle */
+               yaffsfs_SetError(-EBADF);
+               totalRead = -1;
+       } else if(!h->reading){
+               /* 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;
+               else
+                       startPos = h->position;
+
+               pos = startPos;
+                                       
+               if(yaffs_get_obj_length(obj) > pos)
+                       maxRead = yaffs_get_obj_length(obj) - pos;
                else
-               {
                        maxRead = 0;
-               }
 
                if(nbyte > maxRead)
-               {
                        nbyte = maxRead;
+
+
+               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;
                }
 
-               
-               if(nbyte > 0)
-               {
-                       nRead = yaffs_ReadDataFromFile(obj,buf,pos,nbyte);
-                       if(nRead >= 0)
-                       {
-                               h->position = pos + nRead;
+               while(nbyte > 0) {
+                       nToRead = YAFFSFS_RW_SIZE - (pos & (YAFFSFS_RW_SIZE -1));
+                       if(nToRead > nbyte)
+                               nToRead = nbyte;
+
+                       /* 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;
+                               pos += nRead;
+                               buf += nRead;
                        }
+
+                       if(nRead == nToRead)
+                               nbyte-=nRead;
                        else
-                       {
-                               //todo error
+                               nbyte = 0; /* no more to read */
+                                       
+                                       
+                       if(nbyte > 0){
+                               yaffsfs_Unlock();
+                               yaffsfs_Lock();
                        }
+
                }
-               else
-               {
-                       nRead = 0;
+
+               yaffsfs_PutHandle(fd);
+
+               if(!isPread) {
+                       if(totalRead >= 0)
+                               h->position = startPos + totalRead;
+                       else
+                               yaffsfs_SetError(-EINVAL);
                }
-               
+
        }
-       
+
        yaffsfs_Unlock();
-       
-       
-       return (nRead >= 0) ? nRead : -1;
-               
+
+       return (totalRead >= 0) ? totalRead : -1;
+
 }
 
-int yaffs_write(int fd, const void *buf, unsigned int nbyte)
+int yaffs_read(int fd, void *buf, unsigned int nbyte)
+{
+       return yaffsfs_do_read(fd, buf, nbyte, 0, 0);
+}
+
+int yaffs_pread(int fd, void *buf, unsigned int nbyte, unsigned int offset)
+{
+       return yaffsfs_do_read(fd, buf, nbyte, 1, offset);
+}
+
+int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite, int offset)
 {
        yaffsfs_Handle *h = NULL;
-       yaffs_Object *obj = NULL;
+       struct yaffs_obj *obj = NULL;
        int pos = 0;
-       int nWritten = -1;
-       int writeThrough = 0;
-       
+       int startPos = 0;
+       int endPos;
+       int nWritten = 0;
+       int totalWritten = 0;
+       int write_trhrough = 0;
+       int nToWrite = 0;
+       const u8 *buf = (const u8 *)vbuf;
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
-       if(!h || !obj)
-       {
-               // bad handle
-               yaffsfs_SetError(-EBADF);               
-       }
-       else if( h && obj && h->readOnly)
-       {
-               // todo error
-       }
-       else if( h && obj)
-       {
+
+       if(!h || !obj){
+               /* bad handle */
+               yaffsfs_SetError(-EBADF);
+               totalWritten = -1;
+       } else if( h && obj && (!h->writing || obj->my_dev->read_only)){
+               yaffsfs_SetError(-EINVAL);
+               totalWritten=-1;
+       } else {
                if(h->append)
-               {
-                       pos =  yaffs_GetObjectFileLength(obj);
-               }
+                       startPos = yaffs_get_obj_length(obj);
+               else if(isPwrite)
+                       startPos = offset;
                else
-               {
-                       pos = h->position;
+                       startPos = h->position;
+
+               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;
                }
-               
-               nWritten = yaffs_WriteDataToFile(obj,buf,pos,nbyte,writeThrough);
-               
-               if(nWritten >= 0)
-               {
-                       h->position = pos + nWritten;
+
+               while(nbyte > 0) {
+
+                       nToWrite = YAFFSFS_RW_SIZE - (pos & (YAFFSFS_RW_SIZE -1));
+                       if(nToWrite > nbyte)
+                               nToWrite = nbyte;
+
+                       /* 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;
+                               buf += nWritten;
+                       }
+
+                       if(nWritten == nToWrite)
+                               nbyte -= nToWrite;
+                       else
+                               nbyte = 0;
+
+                       if(nWritten < 1 && totalWritten < 1){
+                               yaffsfs_SetError(-ENOSPC);
+                               totalWritten = -1;
+                       }
+
+                       if(nbyte > 0){
+                               yaffsfs_Unlock();
+                               yaffsfs_Lock();
+                       }
                }
-               else
-               {
-                       //todo error
+
+               yaffsfs_PutHandle(fd);
+
+               if(!isPwrite){
+                       if(totalWritten > 0)
+                               h->position = startPos + totalWritten;
+                       else
+                               yaffsfs_SetError(-EINVAL);
                }
-               
        }
-       
+
        yaffsfs_Unlock();
-       
-       
-       return (nWritten >= 0) ? nWritten : -1;
 
+       return (totalWritten >= 0) ? totalWritten : -1;
+}
+
+int yaffs_write(int fd, const void *buf, unsigned int nbyte)
+{
+       return yaffsfs_do_write(fd, buf, nbyte, 0, 0);
+}
+
+int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, unsigned int offset)
+{
+       return yaffsfs_do_write(fd, buf, nbyte, 1, offset);
+}
+
+
+int yaffs_truncate(const YCHAR *path,off_t new_size)
+{
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *dir = NULL;
+       int result = YAFFS_FAIL;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
+       yaffsfs_Lock();
+
+       obj = yaffsfs_FindObject(NULL,path,0,1,&dir);
+
+       if(!dir)
+               yaffsfs_SetError(-ENOTDIR);
+       else if(!obj)
+               yaffsfs_SetError(-ENOENT);
+       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();
+
+       return (result) ? 0 : -1;
 }
 
-int yaffs_truncate(int fd, unsigned int newSize)
+int yaffs_ftruncate(int fd, off_t new_size)
 {
        yaffsfs_Handle *h = NULL;
-       yaffs_Object *obj = NULL;
+       struct yaffs_obj *obj = NULL;
        int result = 0;
-       
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(!h || !obj)
-       {
-               // bad handle
-               yaffsfs_SetError(-EBADF);               
-       }
+               /* 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_ResizeFile(obj,newSize);
-       }       
+               /* resize the file */
+               result = yaffs_resize_file(obj,new_size);
        yaffsfs_Unlock();
-       
-       
+
        return (result) ? 0 : -1;
 
 }
 
-off_t yaffs_lseek(int fd, off_t offset, int whence) 
+off_t yaffs_lseek(int fd, off_t offset, int whence)
 {
        yaffsfs_Handle *h = NULL;
-       yaffs_Object *obj = NULL;
+       struct yaffs_obj *obj = NULL;
        int pos = -1;
        int fSize = -1;
-       
+
        yaffsfs_Lock();
        h = yaffsfs_GetHandlePointer(fd);
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(!h || !obj)
-       {
-               // bad handle
-               yaffsfs_SetError(-EBADF);               
-       }
-       else if(whence == SEEK_SET)
-       {
-               if(offset >= 0)
-               {
-                       pos = offset;
-               }
-       }
-       else if(whence == SEEK_CUR)
-       {
-               if( (h->position + offset) >= 0)
-               {
-                       pos = (h->position + offset);
-               }
-       }
-       else if(whence == SEEK_END)
-       {
-               fSize = yaffs_GetObjectFileLength(obj);
-               if(fSize >= 0 && (fSize + offset) >= 0)
-               {
-                       pos = fSize + offset;
+               yaffsfs_SetError(-EBADF);
+       else if(offset > YAFFS_MAX_FILE_SIZE)
+               yaffsfs_SetError(-EINVAL);
+       else {
+               if(whence == SEEK_SET){
+                       if(offset >= 0)
+                               pos = offset;
+               } else if(whence == SEEK_CUR) {
+                       if( (h->position + offset) >= 0)
+                               pos = (h->position + offset);
+               } else if(whence == SEEK_END) {
+                       fSize = yaffs_get_obj_length(obj);
+                       if(fSize >= 0 && (fSize + offset) >= 0)
+                               pos = fSize + offset;
+               } 
+
+               if(pos >= 0 && pos <= YAFFS_MAX_FILE_SIZE)
+                       h->position = pos;
+               else{
+                       yaffsfs_SetError(-EINVAL);
+                       pos = -1;
                }
        }
-       
-       if(pos >= 0)
-       {
-               h->position = pos;
-       }
-       else
-       {
-               // todo error
-       }
 
-       
        yaffsfs_Unlock();
-       
+
        return pos;
 }
 
 
-int yaffsfs_DoUnlink(const char *path,int isDirectory) 
+int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
 {
-       yaffs_Object *dir = NULL;
-       yaffs_Object *obj = NULL;
-       char *name;
+       struct yaffs_obj *dir = NULL;
+       struct yaffs_obj *obj = NULL;
+       YCHAR *name;
        int result = YAFFS_FAIL;
-       
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
        yaffsfs_Lock();
 
-       obj = yaffsfs_FindObject(NULL,path,0);
+       obj = yaffsfs_FindObject(NULL,path,0,0,NULL);
        dir = yaffsfs_FindDirectory(NULL,path,&name,0);
+
        if(!dir)
-       {
                yaffsfs_SetError(-ENOTDIR);
-       }
        else if(!obj)
-       {
                yaffsfs_SetError(-ENOENT);
-       }
-       else if(!isDirectory && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
-       {
+       else if(obj->my_dev->read_only)
+               yaffsfs_SetError(-EINVAL);
+       else if(!isDirectory && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
                yaffsfs_SetError(-EISDIR);
-       }
-       else if(isDirectory && obj->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
-       {
-               yaffsfs_SetError(-ENOTDIR);
-       }
-       else if(isDirectory && obj->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
-       {
+       else if(isDirectory && obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
                yaffsfs_SetError(-ENOTDIR);
-       }
-       else
-       {
-               result = yaffs_Unlink(dir,name);
-               
+       else {
+               result = yaffs_unlinker(dir,name);
+
                if(result == YAFFS_FAIL && isDirectory)
-               {
                        yaffsfs_SetError(-ENOTEMPTY);
-               }
        }
-       
+
        yaffsfs_Unlock();
-       
-       // todo error
-       
+
+       /* todo error */
+
        return (result == YAFFS_FAIL) ? -1 : 0;
 }
-int yaffs_rmdir(const char *path) 
-{
-       return yaffsfs_DoUnlink(path,1);
-}
 
-int yaffs_unlink(const char *path) 
+
+int yaffs_unlink(const YCHAR *path)
 {
        return yaffsfs_DoUnlink(path,0);
 }
 
-int yaffs_rename(const char *oldPath, const char *newPath)
+int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 {
-       yaffs_Object *olddir = NULL;
-       yaffs_Object *newdir = NULL;
-       yaffs_Object *obj = NULL;
-       char *oldname;
-       char *newname;
+       struct yaffs_obj *olddir = NULL;
+       struct yaffs_obj *newdir = NULL;
+       struct yaffs_obj *obj = NULL;
+       YCHAR *oldname;
+       YCHAR *newname;
        int result= YAFFS_FAIL;
-       int renameAllowed = 1;
-       
+       int rename_allowed = 1;
+
        yaffsfs_Lock();
-       
+
+       if(yaffsfs_CheckPath(newPath) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
        olddir = yaffsfs_FindDirectory(NULL,oldPath,&oldname,0);
        newdir = yaffsfs_FindDirectory(NULL,newPath,&newname,0);
-       obj = yaffsfs_FindObject(NULL,oldPath,0);
-       
-       if(!olddir || !newdir || !obj)
-       {
-               // bad file
-               yaffsfs_SetError(-EBADF);       
-               renameAllowed = 0;      
-       }
-       else if(olddir->myDev != newdir->myDev)
-       {
-               // oops must be on same device
-               // todo error
+       obj = yaffsfs_FindObject(NULL,oldPath,0,0,NULL);
+
+       if(!olddir || !newdir) {
+               yaffsfs_SetError(-ENOTDIR);
+               rename_allowed = 0;
+       } else if(!obj) {
+               yaffsfs_SetError(-ENOENT);
+               rename_allowed = 0;
+       } else if(obj->my_dev->read_only){
+               yaffsfs_SetError(-EROFS);
+               rename_allowed = 0;
+       } else if(olddir->my_dev != newdir->my_dev) {
+               /* Rename must be on same device */
                yaffsfs_SetError(-EXDEV);
-               renameAllowed = 0;      
-       }
-       else if(obj && obj->variantType == 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
-               
-               yaffs_Object *xx = newdir;
-               
-               while( renameAllowed && xx)
-               {
+               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
+                */
+
+               struct yaffs_obj *xx = newdir;
+
+               while( rename_allowed && xx){
                        if(xx == obj)
-                       {
-                               renameAllowed = 0;
-                       }
+                               rename_allowed = 0;
                        xx = xx->parent;
                }
-               if(!renameAllowed) yaffsfs_SetError(-EACCESS);
-       }
-       
-       if(renameAllowed)
-       {
-               result = yaffs_RenameObject(olddir,oldname,newdir,newname);
+               if(!rename_allowed)
+                       yaffsfs_SetError(-EINVAL);
        }
-       
+
+       if(rename_allowed)
+               result = yaffs_rename_obj(olddir,oldname,newdir,newname);
+
        yaffsfs_Unlock();
-       
-       return (result == YAFFS_FAIL) ? -1 : 0; 
+
+       return (result == YAFFS_FAIL) ? -1 : 0;
 }
 
 
-static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
+static int yaffsfs_DoStat(struct yaffs_obj *obj,struct yaffs_stat *buf)
 {
        int retVal = -1;
 
-       if(obj)
-       {
-               obj = yaffs_GetEquivalentObject(obj);
-       }
+       obj = yaffs_get_equivalent_obj(obj);
 
-       if(obj && buf)
-       {
-       buf->st_dev = (int)obj->myDev->genericDevice;
-       buf->st_ino = obj->objectId;
-       buf->st_mode = obj->st_mode & ~S_IFMT; // clear out file type bits
-       
-               if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) 
-               {
+       if(obj && buf){
+               buf->st_dev = (int)obj->my_dev->os_context;
+               buf->st_ino = obj->obj_id;
+               buf->st_mode = obj->yst_mode & ~S_IFMT; /* clear out file type bits */
+
+               if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
                        buf->st_mode |= S_IFDIR;
-               }
-               else if(obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) 
-               {
+               else if(obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK)
                        buf->st_mode |= S_IFLNK;
-               }
-               else if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
-               {
+               else if(obj->variant_type == YAFFS_OBJECT_TYPE_FILE)
                        buf->st_mode |= S_IFREG;
-               }
-               
-       buf->st_nlink = yaffs_GetObjectLinkCount(obj);
-       buf->st_uid = 0;    
-       buf->st_gid = 0;;     
-       buf->st_rdev = obj->st_rdev;
-       buf->st_size = yaffs_GetObjectFileLength(obj);
-               buf->st_blksize = obj->myDev->nBytesPerChunk;
-       buf->st_blocks = (buf->st_size + buf->st_blksize -1)/buf->st_blksize;
-       buf->st_atime = obj->st_atime; 
-       buf->st_ctime = obj->st_ctime; 
-       buf->st_mtime = obj->st_mtime; 
+
+               buf->st_nlink = yaffs_get_obj_link_count(obj);
+               buf->st_uid = 0;
+               buf->st_gid = 0;;
+               buf->st_rdev = obj->yst_rdev;
+               buf->st_size = yaffs_get_obj_length(obj);
+               buf->st_blksize = obj->my_dev->data_bytes_per_chunk;
+               buf->st_blocks = (buf->st_size + buf->st_blksize -1)/buf->st_blksize;
+#if CONFIG_YAFFS_WINCE
+               buf->yst_wince_atime[0] = obj->win_atime[0];
+               buf->yst_wince_atime[1] = obj->win_atime[1];
+               buf->yst_wince_ctime[0] = obj->win_ctime[0];
+               buf->yst_wince_ctime[1] = obj->win_ctime[1];
+               buf->yst_wince_mtime[0] = obj->win_mtime[0];
+               buf->yst_wince_mtime[1] = obj->win_mtime[1];
+#else
+               buf->yst_atime = obj->yst_atime;
+               buf->yst_ctime = obj->yst_ctime;
+               buf->yst_mtime = obj->yst_mtime;
+#endif
                retVal = 0;
        }
        return retVal;
 }
 
-static int yaffsfs_DoStatOrLStat(const char *path, struct yaffs_stat *buf,int doLStat)
+static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int doLStat)
 {
-       yaffs_Object *obj;
-       
+       struct yaffs_obj *obj=NULL;
+       struct yaffs_obj *dir=NULL;
+
        int retVal = -1;
-       
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
        yaffsfs_Lock();
-       obj = yaffsfs_FindObject(NULL,path,0);
-       
+
+       obj = yaffsfs_FindObject(NULL,path,0,1,&dir);
+
        if(!doLStat && obj)
-       {
                obj = yaffsfs_FollowLink(obj,0);
-       }
-       
-       if(obj)
-       {
-               retVal = yaffsfs_DoStat(obj,buf);
-       }
-       else
-       {
-               // todo error not found
+
+       if(!dir)
+               yaffsfs_SetError(-ENOTDIR);
+       else if(!obj)
                yaffsfs_SetError(-ENOENT);
-       }
-       
+       else
+               retVal = yaffsfs_DoStat(obj,buf);
+
        yaffsfs_Unlock();
-       
+
        return retVal;
-       
+
 }
 
-int yaffs_stat(const char *path, struct yaffs_stat *buf)
+int yaffs_stat(const YCHAR *path, struct yaffs_stat *buf)
 {
        return yaffsfs_DoStatOrLStat(path,buf,0);
 }
 
-int yaffs_lstat(const char *path, struct yaffs_stat *buf)
+int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf)
 {
        return yaffsfs_DoStatOrLStat(path,buf,1);
 }
 
 int yaffs_fstat(int fd, struct yaffs_stat *buf)
 {
-       yaffs_Object *obj;
-       
+       struct yaffs_obj *obj;
+
        int retVal = -1;
-       
+
        yaffsfs_Lock();
        obj = yaffsfs_GetHandleObject(fd);
-       
+
        if(obj)
-       {
                retVal = yaffsfs_DoStat(obj,buf);
-       }
        else
-       {
-               // bad handle
-               yaffsfs_SetError(-EBADF);               
-       }
-       
+               /* bad handle */
+               yaffsfs_SetError(-EBADF);
+
        yaffsfs_Unlock();
-       
+
        return retVal;
 }
 
-static int yaffsfs_DoChMod(yaffs_Object *obj,mode_t mode)
+#ifndef CONFIG_YAFFS_WINCE
+/* xattrib functions */
+
+
+static int yaffs_do_setxattr(const YCHAR *path, const char *name, const void *data, int size, int flags, int follow)
 {
-       int result;
+       struct yaffs_obj *obj;
+       struct yaffs_obj *dir;
 
-       if(obj)
-       {
-               obj = yaffs_GetEquivalentObject(obj);
+       int retVal = -1;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
        }
-       
-       if(obj)
-       {
-               obj->st_mode = mode;
-               obj->dirty = 1;
-               result = yaffs_FlushFile(obj,0);
+
+       yaffsfs_Lock();
+
+       obj = yaffsfs_FindObject(NULL,path,0,1,&dir);
+
+       if(follow)
+               obj = yaffsfs_FollowLink(obj,0);
+
+       if(!dir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(!obj) 
+               yaffsfs_SetError(-ENOENT);
+       else {
+               retVal = yaffs_set_xattrib(obj,name,data,size,flags);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
        }
-       
-       return result == YAFFS_OK ? 0 : -1;
+
+       yaffsfs_Unlock();
+
+       return retVal;
+
+}
+
+int yaffs_setxattr(const YCHAR *path, const char *name, const void *data, int size, int flags)
+{
+       return yaffs_do_setxattr(path, name, data, size, flags, 1);
+}
+
+int yaffs_lsetxattr(const YCHAR *path, const char *name, const void *data, int size, int flags)
+{
+       return yaffs_do_setxattr(path, name, data, size, flags, 0);
 }
 
 
-int yaffs_chmod(const char *path, mode_t mode)
+
+int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int flags)
 {
-       yaffs_Object *obj;
-       
+       struct yaffs_obj *obj;
+
        int retVal = -1;
-       
+
        yaffsfs_Lock();
-       obj = yaffsfs_FindObject(NULL,path,0);
-       
-       if(obj)
-       {
-               retVal = yaffsfs_DoChMod(obj,mode);
-       }
-       else
-       {
-               // todo error not found
-               yaffsfs_SetError(-ENOENT);
+       obj = yaffsfs_GetHandleObject(fd);
+
+       if(!obj) 
+               yaffsfs_SetError(-EBADF);
+       else {
+               retVal = yaffs_set_xattrib(obj,name,data,size,flags);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
-       
 }
 
-
-int yaffs_fchmod(int fd, mode_t mode)
+static int yaffs_do_getxattr(const YCHAR *path, const char *name, void *data, int size, int follow)
 {
-       yaffs_Object *obj;
-       
+       struct yaffs_obj *obj;
+       struct yaffs_obj *dir;
+
        int retVal = -1;
-       
-       yaffsfs_Lock();
-       obj = yaffsfs_GetHandleObject(fd);
-       
-       if(obj)
-       {
-               retVal = yaffsfs_DoChMod(obj,mode);
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
        }
-       else
-       {
-               // bad handle
-               yaffsfs_SetError(-EBADF);               
+
+       yaffsfs_Lock();
+
+       obj = yaffsfs_FindObject(NULL,path,0,1,&dir);
+
+       if(follow)
+               obj = yaffsfs_FollowLink(obj,0);
+
+       if(!dir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(!obj) 
+               yaffsfs_SetError(-ENOENT);
+       else {
+               retVal = yaffs_get_xattrib(obj,name,data,size);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
        }
-       
        yaffsfs_Unlock();
-       
+
        return retVal;
+
+}
+
+int yaffs_getxattr(const YCHAR *path, const char *name, void *data, int size)
+{
+       return yaffs_do_getxattr( path, name, data, size, 1);
+}
+int yaffs_lgetxattr(const YCHAR *path, const char *name, void *data, int size)
+{
+       return yaffs_do_getxattr( path, name, data, size, 0);
 }
 
 
-int yaffs_mkdir(const char *path, mode_t mode)
+
+int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
 {
-       yaffs_Object *parent = NULL;
-       yaffs_Object *dir;
-       char *name;
-       int retVal= -1;
-       
+       struct yaffs_obj *obj;
+
+       int retVal = -1;
+
        yaffsfs_Lock();
-       parent = yaffsfs_FindDirectory(NULL,path,&name,0);
-       dir = yaffs_MknodDirectory(parent,name,mode,0,0);
-       if(dir)
-       {
-               retVal = 0;
-       }
-       else
-       {
-               yaffsfs_SetError(-ENOSPC); // just assume no space for now
-               retVal = -1;
-       }
-       
+       obj = yaffsfs_GetHandleObject(fd);
+
+       if(obj) {
+               retVal = yaffs_get_xattrib(obj,name,data,size);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
+       } else
+               /* bad handle */
+               yaffsfs_SetError(-EBADF);
+
        yaffsfs_Unlock();
-       
+
        return retVal;
 }
 
-int yaffs_mount(const char *path)
+static int yaffs_do_listxattr(const YCHAR *path, char *data, int size, int follow)
 {
-       int retVal=-1;
-       int result=YAFFS_FAIL;
-       yaffs_Device *dev=NULL;
-       char *dummy;
-       
-       T(YAFFS_TRACE_ALWAYS,("yaffs: Mounting %s\n",path));
-       
+       struct yaffs_obj *obj=NULL;
+       struct yaffs_obj *dir=NULL;
+
+       int retVal = -1;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
        yaffsfs_Lock();
-       dev = yaffsfs_FindDevice(path,&dummy);
-       if(dev)
-       {
-               if(!dev->isMounted)
-               {
-                       result = yaffs_GutsInitialise(dev);
-                       if(result == YAFFS_FAIL)
-                       {
-                               // todo error - mount failed
-                               yaffsfs_SetError(-ENOMEM);
-                       }
-                       retVal = result ? 0 : -1;
-                       
-               }
-               else
-               {
-                       //todo error - already mounted.
-                       yaffsfs_SetError(-EBUSY);
+
+       obj = yaffsfs_FindObject(NULL,path,0,1,&dir);
+
+       if(follow)
+               obj = yaffsfs_FollowLink(obj,0);
+
+       if(!dir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(!obj) 
+               yaffsfs_SetError(-ENOENT);
+       else {
+               retVal = yaffs_list_xattrib(obj, data,size);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
                }
        }
-       else
-       {
-               // todo error - no device
-               yaffsfs_SetError(-ENODEV);
-       }
+
        yaffsfs_Unlock();
+
        return retVal;
-       
+
 }
 
-int yaffs_unmount(const char *path)
+int yaffs_listxattr(const YCHAR *path, char *data, int size)
 {
-       int retVal=-1;
-       yaffs_Device *dev=NULL;
-       char *dummy;
-       
-       yaffsfs_Lock();
-       dev = yaffsfs_FindDevice(path,&dummy);
-       if(dev)
-       {
-               if(dev->isMounted)
-               {
-                       int i;
-                       int inUse;
-                       for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse; i++)
-                       {
-                               if(yaffsfs_handle[i].inUse && yaffsfs_handle[i].obj->myDev == dev)
-                               {
-                                       inUse = 1; // the device is in use, can't unmount
-                               }
-                       }
-                       
-                       if(!inUse)
-                       {
-                               yaffs_Deinitialise(dev);
-                                       
+       return yaffs_do_listxattr(path, data, size, 1);
+}
+
+int yaffs_llistxattr(const YCHAR *path, char *data, int size)
+{
+       return yaffs_do_listxattr(path, data, size, 0);
+}
+
+int yaffs_flistxattr(int fd, char *data, int size)
+{
+       struct yaffs_obj *obj;
+
+       int retVal = -1;
+
+       yaffsfs_Lock();
+       obj = yaffsfs_GetHandleObject(fd);
+
+       if(obj) {
+               retVal = yaffs_list_xattrib(obj,data,size);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
+       } else
+               /* bad handle */
+               yaffsfs_SetError(-EBADF);
+
+       yaffsfs_Unlock();
+
+       return retVal;
+}
+
+static int yaffs_do_removexattr(const YCHAR *path, const char *name, int follow)
+{
+       struct yaffs_obj *obj=NULL;
+       struct yaffs_obj *dir=NULL;
+
+       int retVal = -1;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
+       yaffsfs_Lock();
+
+       obj = yaffsfs_FindObject(NULL,path,0,1, &dir);
+
+       if(follow)
+               obj = yaffsfs_FollowLink(obj,0);
+
+       if(!dir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(!obj) 
+               yaffsfs_SetError(-ENOENT);
+       else {
+               retVal = yaffs_remove_xattrib(obj,name);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
+       }
+
+       yaffsfs_Unlock();
+
+       return retVal;
+
+}
+
+int yaffs_removexattr(const YCHAR *path, const char *name)
+{
+       return yaffs_do_removexattr(path, name, 1);
+}
+
+int yaffs_lremovexattr(const YCHAR *path, const char *name)
+{
+       return yaffs_do_removexattr(path, name, 0);
+}
+
+int yaffs_fremovexattr(int fd, const char *name)
+{
+       struct yaffs_obj *obj;
+
+       int retVal = -1;
+
+       yaffsfs_Lock();
+       obj = yaffsfs_GetHandleObject(fd);
+
+       if(obj){
+               retVal = yaffs_remove_xattrib(obj,name);
+               if(retVal< 0){
+                       yaffsfs_SetError(retVal);
+                       retVal = -1;
+               }
+       }else
+               /* bad handle */
+               yaffsfs_SetError(-EBADF);
+
+       yaffsfs_Unlock();
+
+       return retVal;
+}
+#endif
+
+#ifdef CONFIG_YAFFS_WINCE
+int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *wmtime)
+{
+       struct yaffs_obj *obj;
+
+       int retVal = -1;
+
+       yaffsfs_Lock();
+       obj = yaffsfs_GetHandleObject(fd);
+
+       if(obj){
+
+               if(wctime){
+                       wctime[0] = obj->win_ctime[0];
+                       wctime[1] = obj->win_ctime[1];
+               }
+               if(watime){
+                       watime[0] = obj->win_atime[0];
+                       watime[1] = obj->win_atime[1];
+               }
+               if(wmtime){
+                       wmtime[0] = obj->win_mtime[0];
+                       wmtime[1] = obj->win_mtime[1];
+               }
+
+
+               retVal = 0;
+       } else
+               /*  bad handle */
+               yaffsfs_SetError(-EBADF);               
+       
+       yaffsfs_Unlock();
+       
+       return retVal;
+}
+
+
+int yaffs_set_wince_times(int fd, 
+                                                 const unsigned *wctime, 
+                                                 const unsigned *watime, 
+                                                  const unsigned *wmtime)
+{
+        struct yaffs_obj *obj;
+        int result;
+        int retVal = -1;
+
+        yaffsfs_Lock();
+       obj = yaffsfs_GetHandleObject(fd);
+
+       if(obj){
+
+               if(wctime){
+                       obj->win_ctime[0] = wctime[0];
+                       obj->win_ctime[1] = wctime[1];
+               }
+               if(watime){
+                        obj->win_atime[0] = watime[0];
+                        obj->win_atime[1] = watime[1];
+                }
+                if(wmtime){
+                        obj->win_mtime[0] = wmtime[0];
+                        obj->win_mtime[1] = wmtime[1];
+                }
+
+                obj->dirty = 1;
+                result = yaffs_flush_file(obj,0,0);
+                retVal = 0;
+        } else
+               /* bad handle */
+               yaffsfs_SetError(-EBADF);
+
+       yaffsfs_Unlock();
+
+       return retVal;
+}
+
+#endif
+
+
+static int yaffsfs_DoChMod(struct yaffs_obj *obj,mode_t mode)
+{
+       int result = -1;
+
+       if(obj)
+               obj = yaffs_get_equivalent_obj(obj);
+
+       if(obj) {
+               obj->yst_mode = mode;
+               obj->dirty = 1;
+               result = yaffs_flush_file(obj,0,0);
+       }
+
+       return result == YAFFS_OK ? 0 : -1;
+}
+
+
+int yaffs_access(const YCHAR *path, int amode)
+{
+       struct yaffs_obj *obj=NULL;
+       struct yaffs_obj *dir=NULL;
+
+       int retval = -1;
+
+       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, &dir);
+
+       if(!dir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(!obj) 
+               yaffsfs_SetError(-ENOENT);
+       else {
+               int access_ok = 1;
+
+               if((amode & R_OK) && !(obj->yst_mode & S_IREAD))
+                       access_ok = 0;
+               if((amode & W_OK) && !(obj->yst_mode & S_IWRITE))
+                       access_ok = 0;
+               if((amode & X_OK) && !(obj->yst_mode & S_IEXEC))
+                       access_ok = 0;
+
+               if(!access_ok)
+                       yaffsfs_SetError(-EACCES);
+               else
+                       retval = 0;
+       }
+
+       yaffsfs_Unlock();
+
+       return retval;
+
+}
+
+
+int yaffs_chmod(const YCHAR *path, mode_t mode)
+{
+       struct yaffs_obj *obj=NULL;
+       struct yaffs_obj *dir=NULL;
+       int retVal = -1;
+
+       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, &dir);
+
+       if(!dir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(!obj) 
+               yaffsfs_SetError(-ENOENT);
+       else if(obj->my_dev->read_only)
+               yaffsfs_SetError(-EROFS);
+       else
+               retVal = yaffsfs_DoChMod(obj,mode);
+
+       yaffsfs_Unlock();
+
+       return retVal;
+
+}
+
+
+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(-EBADF);
+       else if(obj->my_dev->read_only)
+               yaffsfs_SetError(-EROFS);
+       else
+               retVal = yaffsfs_DoChMod(obj,mode);
+
+       yaffsfs_Unlock();
+
+       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;
+}
+
+int yaffs_mkdir(const YCHAR *path, mode_t mode)
+{
+       struct yaffs_obj *parent = NULL;
+       struct yaffs_obj *dir = NULL;
+       YCHAR *name;
+       YCHAR *alt_path = NULL;
+       int retVal= -1;
+
+       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;
+       
+       yaffsfs_Lock();
+       parent = yaffsfs_FindDirectory(NULL,path,&name,0);
+       if(!parent)
+               yaffsfs_SetError(-ENOTDIR);
+       else if(parent && yaffs_strnlen(name,5) == 0){
+               /* Trying to make the root itself */
+               yaffsfs_SetError(-EEXIST);
+       } else if(parent && parent->my_dev->read_only)
+               yaffsfs_SetError(-EROFS);
+       else {
+               dir = yaffs_create_dir(parent,name,mode,0,0);
+               if(dir)
+                       retVal = 0;
+               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(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;
+       YCHAR *dummy;
+       dev = yaffsfs_FindDevice(path,&dummy);
+       return (void *)dev;
+}
+
+int yaffs_mount2(const YCHAR *path,int read_only)
+{
+       int retVal=-1;
+       int result=YAFFS_FAIL;
+       struct yaffs_dev *dev=NULL;
+
+       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_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();
+       return retVal;
+
+}
+
+int yaffs_mount(const YCHAR *path)
+{
+       return yaffs_mount2(path,0);
+}
+
+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){
+                        
+                        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();
+        return retVal;  
+}
+
+
+int yaffs_remount(const YCHAR *path, int force, int read_only)
+{
+        int retVal=-1;
+       struct yaffs_dev *dev=NULL;
+       yaffsfs_Handle *yh;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
+       yaffsfs_Lock();
+       dev = yaffsfs_FindMountPoint(path);
+       if(dev){
+               if(dev->is_mounted){
+                       int i;
+                       int inUse;
+
+                       yaffs_flush_whole_cache(dev);
+
+                       for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse && !force; i++){
+                               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 */
+                       }
+
+                       if(!inUse || force){
+                               if(read_only)
+                                       yaffs_checkpoint_save(dev);
+                               dev->read_only =  read_only ? 1 : 0;
+                               retVal = 0;
+                       } else
+                               yaffsfs_SetError(-EBUSY);
+
+               } else
+                       yaffsfs_SetError(-EINVAL);
+
+       }
+       else
+               yaffsfs_SetError(-ENODEV);
+
+       yaffsfs_Unlock();
+       return retVal;
+
+}
+
+int yaffs_unmount2(const YCHAR *path, int force)
+{
+        int retVal=-1;
+       struct yaffs_dev *dev=NULL;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
+       yaffsfs_Lock();
+       dev = yaffsfs_FindMountPoint(path);
+       if(dev){
+               if(dev->is_mounted){
+                       int i;
+                       int inUse;
+
+                       yaffs_flush_whole_cache(dev);
+                       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)
+                                       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
+                       } else
+                               /* todo error can't unmount as files are open */
                                yaffsfs_SetError(-EBUSY);
-                       }
-                       
-               }
-               else
-               {
-                       //todo error - not mounted.
+
+               } else
+                       /* todo error - not mounted. */
                        yaffsfs_SetError(-EINVAL);
-                       
-               }
-       }
-       else
-       {
-               // todo error - no device
+
+       } else
+               /* todo error - no device */
                yaffsfs_SetError(-ENODEV);
-       }       
+
        yaffsfs_Unlock();
        return retVal;
-       
+
 }
 
-off_t yaffs_freespace(const char *path)
+int yaffs_unmount(const YCHAR *path)
 {
-       off_t retVal=-1;
-       yaffs_Device *dev=NULL;
-       char *dummy;
-       
+       return yaffs_unmount2(path,0);
+}
+
+loff_t yaffs_freespace(const YCHAR *path)
+{
+       loff_t 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  && dev->isMounted)
-       {
-               retVal = yaffs_GetNumberOfFreeChunks(dev);
-               retVal *= dev->nBytesPerChunk;
-               
+       if(dev  && dev->is_mounted){
+               retVal = yaffs_get_n_free_chunks(dev);
+               retVal *= dev->data_bytes_per_chunk;
+
+       } else
+               yaffsfs_SetError(-EINVAL);
+
+       yaffsfs_Unlock();
+       return retVal;
+}
+
+loff_t yaffs_totalspace(const YCHAR *path)
+{
+       loff_t retVal=-1;
+       struct yaffs_dev *dev=NULL;
+       YCHAR *dummy;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
        }
-       else
-       {
+
+       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.chunks_per_block;
+               retVal *= dev->data_bytes_per_chunk;
+
+       } else
                yaffsfs_SetError(-EINVAL);
+
+       yaffsfs_Unlock();
+       return retVal;
+}
+
+int yaffs_inodecount(const YCHAR *path)
+{
+       loff_t 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  && dev->is_mounted) {
+          int n_obj = dev->n_obj;
+          if(n_obj > dev->n_hardlinks)
+               retVal = n_obj - dev->n_hardlinks;
        }
        
+       if(retVal < 0)
+               yaffsfs_SetError(-EINVAL);
+       
        yaffsfs_Unlock();
        return retVal;  
 }
 
-void yaffs_initialise(yaffsfs_DeviceConfiguration *cfgList)
+
+void yaffs_add_device(struct yaffs_dev *dev)
 {
-       
-       yaffsfs_DeviceConfiguration *cfg;
-       
-       yaffsfs_configurationList = cfgList;
-       
-       yaffsfs_InitHandles();
-       
-       cfg = yaffsfs_configurationList;
-       
-       while(cfg && cfg->prefix && cfg->dev)
-       {
-               cfg->dev->isMounted = 0;
-               cfg++;
+       dev->is_mounted = 0;
+       dev->param.remove_obj_fn = yaffsfs_RemoveObjectCallback;
+
+       if(!dev->dev_list.next)
+               INIT_LIST_HEAD(&dev->dev_list);
+
+       list_add(&dev->dev_list,&yaffsfs_deviceList);
+}
+
+void yaffs_remove_device(struct yaffs_dev *dev)
+{
+       list_del_init(&dev->dev_list);
+}
+
+
+
+
+/* Directory search stuff. */
+
+/*
+ * Directory search context
+ *
+ * NB this is an opaque structure.
+ */
+
+
+typedef struct
+{
+       u32 magic;
+       yaffs_dirent de;                /* directory entry being used by this dsc */
+       YCHAR name[NAME_MAX+1];         /* name of directory being searched */
+        struct yaffs_obj *dirObj;           /* ptr to directory being searched */
+        struct yaffs_obj *nextReturn;       /* obj to be returned by next readddir */
+        int offset;
+        struct list_head others;       
+} yaffsfs_DirectorySearchContext;
+
+
+
+static struct list_head search_contexts;
+
+
+static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc)
+{
+       if(dsc &&
+          dsc->dirObj &&
+          dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
+
+           dsc->offset = 0;
+
+           if( list_empty(&dsc->dirObj->variant.dir_variant.children))
+                dsc->nextReturn = NULL;
+           else
+                dsc->nextReturn = list_entry(dsc->dirObj->variant.dir_variant.children.next,
+                                                struct yaffs_obj,siblings);
+        } else {
+               /* Hey someone isn't playing nice! */
+       }
+}
+
+static void yaffsfs_DirAdvance(yaffsfs_DirectorySearchContext *dsc)
+{
+       if(dsc &&
+          dsc->dirObj &&
+           dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
+
+           if( dsc->nextReturn == NULL ||
+               list_empty(&dsc->dirObj->variant.dir_variant.children))
+                dsc->nextReturn = NULL;
+           else {
+                   struct list_head *next = dsc->nextReturn->siblings.next;
+
+                   if( next == &dsc->dirObj->variant.dir_variant.children)
+                        dsc->nextReturn = NULL; /* end of list */
+                   else
+                        dsc->nextReturn = list_entry(next,struct yaffs_obj,siblings);
+           }
+        } else {
+                /* Hey someone isn't playing nice! */
        }
-       
-       
 }
 
+static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj)
+{
+
+        struct list_head *i;
+        yaffsfs_DirectorySearchContext *dsc;
 
-//
-// Directory search stuff.
+        /* if search contexts not initilised then skip */
+        if(!search_contexts.next)
+                return;
 
-yaffs_DIR *yaffs_opendir(const char *dirname)
+        /* Iterate through the directory search contexts.
+         * If any are the one being removed, then advance the dsc to
+         * the next one to prevent a hanging ptr.
+         */
+         list_for_each(i, &search_contexts) {
+                if (i) {
+                        dsc = list_entry(i, yaffsfs_DirectorySearchContext,others);
+                        if(dsc->nextReturn == obj)
+                                yaffsfs_DirAdvance(dsc);
+                }
+       }
+
+}
+
+yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
 {
        yaffs_DIR *dir = NULL;
-       yaffs_Object *obj = NULL;
+       struct yaffs_obj *obj = NULL;
        yaffsfs_DirectorySearchContext *dsc = NULL;
-       
+
+       if(yaffsfs_CheckPath(dirname) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
        yaffsfs_Lock();
-       
-       obj = yaffsfs_FindObject(NULL,dirname,0);
-       
-       if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
-       {
-               
+
+       obj = yaffsfs_FindObject(NULL,dirname,0,1,NULL);
+
+       if(obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
+
                dsc = YMALLOC(sizeof(yaffsfs_DirectorySearchContext));
                dir = (yaffs_DIR *)dsc;
-               if(dsc)
-               {
-                       dsc->magic = YAFFS_MAGIC;
-                       dsc->list = NULL;
-                       memset(dsc->name,0,NAME_MAX+1);
-                       strncpy(dsc->name,dirname,NAME_MAX);
+
+               if(dsc){
+                       memset(dsc,0,sizeof(yaffsfs_DirectorySearchContext));
+                        dsc->magic = YAFFS_MAGIC;
+                        dsc->dirObj = obj;
+                        yaffs_strncpy(dsc->name,dirname,NAME_MAX);
+                        INIT_LIST_HEAD(&dsc->others);
+
+                        if(!search_contexts.next)
+                                INIT_LIST_HEAD(&search_contexts);
+
+                        list_add(&dsc->others,&search_contexts);       
+                        yaffsfs_SetDirRewound(dsc);
                }
-       
-       }
-       
+
+        }
+
        yaffsfs_Unlock();
-       
+
        return dir;
 }
 
@@ -1198,110 +2436,44 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
 {
        yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
        struct yaffs_dirent *retVal = NULL;
-       struct list_head *i;    
-       yaffs_Object *entry = NULL;
-       int offset;
-       yaffs_Object *obj = NULL;
-       struct yaffsfs_ObjectListEntry *list = NULL;
-       int inList = 0;
-               
+
        yaffsfs_Lock();
-       
-       offset = -1;
-       
-       if(dsc && dsc->magic == YAFFS_MAGIC)
-       {
+
+       if(dsc && dsc->magic == YAFFS_MAGIC){
                yaffsfs_SetError(0);
-               
-               obj = yaffsfs_FindObject(NULL,dsc->name,0);
-       
-               if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
-               {
-                       
-                       list_for_each(i,&obj->variant.directoryVariant.children)
-                       {               
-                                       offset++;
-                                       entry = (i) ?  list_entry(i, yaffs_Object,siblings) : NULL;
-                       
-                                       if(entry)
-                                       {
-                                               list = dsc->list;
-                                               inList = 0;
-                                               while(list && !inList)
-                                               {
-                                                       if(list->objectId == entry->objectId)
-                                                       {
-                                                               inList = 1;
-                                                       }
-                                                       list = list->next;
-                                               }
-                                               
-                                               if(!inList) goto foundNew;
-                                       }
-                               
-                       }
-                       
-                       foundNew:
-                       
-                       if(!inList && entry)
+               if(dsc->nextReturn){
+                       dsc->de.d_ino = yaffs_get_equivalent_obj(dsc->nextReturn)->obj_id;
+                       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(yaffs_strnlen(dsc->de.d_name,NAME_MAX+1) == 0)
                        {
-                               //This is the entry we're going to return;
-                               struct yaffsfs_ObjectListEntry *le;
-                               
-                               le = YMALLOC(sizeof(struct yaffsfs_ObjectListEntry));
-                               
-                               if(le)
-                               {
-                                       le->next =  dsc->list;
-                                       le->objectId = entry->objectId;
-                                       dsc->list = le;
-                                       
-                                       dsc->de.d_ino = yaffs_GetEquivalentObject(entry)->objectId;
-                                       dsc->de.d_off = offset;
-                                       yaffs_GetObjectName(entry,dsc->de.d_name,NAME_MAX+1);
-                                       dsc->de.d_reclen = sizeof(struct yaffs_dirent);
-                                       
-                                       retVal = &dsc->de;
-                               }
-                               
+                               /* this should not happen! */
+                               yaffs_strcpy(dsc->de.d_name,_Y("zz"));
                        }
-               }
-
-       }
-       else
-       {
+                       dsc->de.d_reclen = sizeof(struct yaffs_dirent);
+                       retVal = &dsc->de;
+                       yaffsfs_DirAdvance(dsc);
+               } else
+                       retVal = NULL;
+       } else
                yaffsfs_SetError(-EBADF);
-       }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
-       
-}
 
-void yaffsfs_ListClear(yaffsfs_DirectorySearchContext *dsc) 
-{
-       
-       struct yaffsfs_ObjectListEntry *le;
-       
-       if(dsc && dsc->magic == YAFFS_MAGIC)
-       {
-               while(dsc->list)
-               {
-                       le = dsc->list;
-                       dsc->list = dsc->list->next;
-                       YFREE(le);
-               }
-       }
-       
 }
 
+
 void yaffs_rewinddir(yaffs_DIR *dirp)
 {
        yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
-               
+
        yaffsfs_Lock();
-       yaffsfs_ListClear(dsc);
+
+       yaffsfs_SetDirRewound(dsc);
+
        yaffsfs_Unlock();
 }
 
@@ -1309,105 +2481,210 @@ void yaffs_rewinddir(yaffs_DIR *dirp)
 int yaffs_closedir(yaffs_DIR *dirp)
 {
        yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
-               
-       yaffsfs_Lock();
-       yaffsfs_ListClear(dsc);
-       dsc->magic = 0;
-       YFREE(dsc);
-       yaffsfs_Unlock();
-       return 0;
+
+        yaffsfs_Lock();
+        dsc->magic = 0;
+        list_del(&dsc->others); /* unhook from list */
+        YFREE(dsc);
+        yaffsfs_Unlock();
+        return 0;
 }
 
+/* End of directory stuff */
 
 
-int yaffs_symlink(const char *oldpath, const char *newpath)
+int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 {
-       yaffs_Object *parent = NULL;
-       yaffs_Object *obj;
-       char *name;
+       struct yaffs_obj *parent = NULL;
+       struct yaffs_obj *obj;
+       YCHAR *name;
        int retVal= -1;
-       int mode = 0; // ignore for now
-       
+       int mode = 0; /* ignore for now */
+
+       if(yaffsfs_CheckPath(newpath) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
        yaffsfs_Lock();
        parent = yaffsfs_FindDirectory(NULL,newpath,&name,0);
-       obj = yaffs_MknodSymLink(parent,name,mode,0,0,oldpath);
-       if(obj)
-       {
-               retVal = 0;
-       }
-       else
-       {
-               yaffsfs_SetError(-ENOSPC); // just assume no space for now
-               retVal = -1;
+       if(!parent)
+               yaffsfs_SetError(-ENOTDIR);
+       else if( strlen(name) < 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 if (yaffsfs_FindObject(NULL,newpath,0,0, NULL))
+                       yaffsfs_SetError(-EEXIST);
+               else
+                       yaffsfs_SetError(-ENOSPC);
        }
-       
+
        yaffsfs_Unlock();
-       
+
        return retVal;
-       
+
 }
 
-int yaffs_readlink(const char *path, char *buf, int bufsiz)
+int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 {
-       yaffs_Object *obj = NULL;
-       int retVal;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *dir = NULL;
+       int retVal= -1;
 
-               
        yaffsfs_Lock();
-       
-       obj = yaffsfs_FindObject(NULL,path,0);
-       
-       if(!obj)
-       {
+
+       obj = yaffsfs_FindObject(NULL,path,0,1, &dir);
+
+       if(!dir) 
+               yaffsfs_SetError(-ENOTDIR);
+       else if(!obj) 
                yaffsfs_SetError(-ENOENT);
-               retVal = -1;
-       }
-       else if(obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK)
-       {
+       else if(obj->variant_type != YAFFS_OBJECT_TYPE_SYMLINK)
                yaffsfs_SetError(-EINVAL);
-               retVal = -1;
-       }
-       else
-       {
-               char *alias = obj->variant.symLinkVariant.alias;
+       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();
        return retVal;
 }
 
-int yaffs_link(const char *oldpath, const char *newpath); 
-int yaffs_mknod(const char *pathname, mode_t mode, dev_t dev);
+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 *lnk = NULL;
+       int retVal = -1;
+
+       if(yaffsfs_CheckPath(linkpath) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
+       yaffsfs_Lock();
+
+       obj = yaffsfs_FindObject(NULL,oldpath,0,1,NULL);
+       lnk = yaffsfs_FindObject(NULL,linkpath,0,0,NULL);
+
+       if(!obj)
+               yaffsfs_SetError(-ENOENT);
+       else if(obj->my_dev->read_only)
+               yaffsfs_SetError(-EINVAL);
+       else if(lnk)
+               yaffsfs_SetError(-EEXIST);
+       else {
+               struct yaffs_obj *newdir = NULL;
+               struct yaffs_obj *link = NULL;
+
+               YCHAR *newname;
+
+               newdir = yaffsfs_FindDirectory(NULL,linkpath,&newname,0);
+
+               if(!newdir)
+                       yaffsfs_SetError(-ENOTDIR);
+               else if(newdir->my_dev != obj->my_dev)
+                       yaffsfs_SetError(-EXDEV);
+               
+               retVal = yaffsfs_CheckNameLength(newname);
+               
+               if(retVal == 0) {
+                       link = yaffs_link_obj(newdir,newname,obj);
+                       if(link)
+                               retVal = 0;
+                       else{
+                               yaffsfs_SetError(-ENOSPC);
+                               retVal = -1;
+                       }
+
+               }
+       }
+       yaffsfs_Unlock();
+
+       return retVal;
+}
 
-int yaffs_DumpDevStruct(const char *path)
+int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev)
 {
-       char *rest;
-       
-       yaffs_Object *obj = yaffsfs_FindRoot(path,&rest);
-       
+       pathname=pathname;
+       mode=mode;
+       dev=dev;
+
+       yaffsfs_SetError(-EINVAL);
+       return -1;
+}
+
+
+
+/*
+ * yaffs_n_handles()
+ * Returns number of handles attached to the object
+ */
+int yaffs_n_handles(const YCHAR *path)
+{
+       struct yaffs_obj *obj;
+
+       if(yaffsfs_CheckPath(path) < 0){
+               yaffsfs_SetError(-ENAMETOOLONG);
+               return -1;
+       }
+
+       obj = yaffsfs_FindObject(NULL,path,0,1,NULL);
+
        if(obj)
-       {
-               yaffs_Device *dev = obj->myDev;
-               
+               return yaffsfs_CountHandles(obj);
+       else
+               return -1;
+}
+
+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 1
+       path=path;
+#else
+       YCHAR *rest;
+
+       struct yaffs_obj *obj = yaffsfs_FindRoot(path,&rest);
+
+       if(obj){
+               struct yaffs_dev *dev = obj->my_dev;
+
                printf("\n"
-                          "nPageWrites.......... %d\n"
-                          "nPageReads........... %d\n"
-                          "nBlockErasures....... %d\n"
-                          "nGCCopies............ %d\n"
+                          "n_page_writes.......... %d\n"
+                          "n_page_reads........... %d\n"
+                          "n_erasures....... %d\n"
+                          "n_gc_copies............ %d\n"
                           "garbageCollections... %d\n"
                           "passiveGarbageColl'ns %d\n"
                           "\n",
-                               dev->nPageWrites,
-                               dev->nPageReads,
-                               dev->nBlockErasures,
-                               dev->nGCCopies,
+                               dev->n_page_writes,
+                               dev->n_page_reads,
+                               dev->n_erasures,
+                               dev->n_gc_copies,
                                dev->garbageCollections,
                                dev->passiveGarbageCollections
                );
-               
+
        }
+
+#endif
        return 0;
 }