WebSVN - NaviCtrl - Diff - Rev 427 and 431

         u16     end_of_directory_not_reached = 0;
         u8              i = 0;
         u8      direntry_exist = 0;
         DirEntry_t * dir;
-        // if incomming pointers are useless return immediatly
+        // incomming pointers are useless?
         if((!Partition.IsValid) || (file == NULL) || (dirname == NULL)) return(direntry_exist);
-        // dir entries can be searched only in filesclusters that have
+        // check sector range to be searched
-        // a corresponding dir entry with a dir-flag set in its attribute
-        // or direct within the root directory area
-        file->FirstSectorOfFirstCluster = SECTOR_UNDEFINED;
-        // no current directory exist therefore assume searching in the root
+        // no search area defined?
-        if(file->DirectorySector == SECTOR_UNDEFINED)
-        {
+        if(file->FirstSectorOfFirstCluster == SECTOR_UNDEFINED)
                 max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
-                file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
+                return(direntry_exist);
         }
-        // within the root directory area we can read sectors sequentially until the end of this area
+        //is search area the root?
-        else if((Partition.FirstRootDirSector <= file->DirectorySector) && (file->DirectorySector < Partition.FirstDataSector))
+        else if(Partition.FirstRootDirSector == file->FirstSectorOfFirstCluster)
         {
-                max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
+                max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR; // limit to  size of root
-                file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
+                file->DirectorySector = SECTOR_UNDEFINED; // if we have to search within the root, there is no corresponding directory entry available
         }
-        // within the data clusters we can read sectors sequentially only within the cluster
+        // is search area within the data cluster range?
-        else if((Partition.FirstDataSector <= file->DirectorySector) && (file->DirectorySector <= Partition.LastDataSector))
+        else if((Partition.FirstDataSector <= file->FirstSectorOfFirstCluster) && (file->FirstSectorOfFirstCluster <= Partition.LastDataSector))
         {
-                max_dir_sector = Partition.SectorsPerCluster;                           // limit max sectors before next cluster
-        }
+                max_dir_sector = Partition.SectorsPerCluster;                           // limit max sectors before next cluster
-        else return (direntry_exist); // bad sector range for directory sector of the file
+                /*
-        // if search area is not defined yet, i.e. not in the root directory area
-        if(file->FirstSectorOfFirstCluster == SECTOR_UNDEFINED)
-        {
-                // check if the directory entry of current file is existent and has the dir-flag set
-                file->SectorInCache = file->DirectorySector;                            // update the sector number of file cache.
+                //there must be a corresponding directory entry
-                if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
+                if(file->DirectorySector == SECTOR_UNDEFINED)
-                {
                         Fat16_Deinit();
-                        return(0);
+                        return (direntry_exist);
-                }
                 dir = (DirEntry_t *)file->Cache;                                                        // set pointer to directory
+                else // check directory entry
+                {
+                        file->SectorInCache = file->DirectorySector;                            // update the sector number of file cache.
+                        if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
+                        {
+                                Fat16_Deinit();
+                                return (direntry_exist);
+                        }
+                        dir = (DirEntry_t *)file->Cache;                                                        // set pointer to directory
-                switch((u8)dir[file->DirectoryIndex].Name[0])                           // check if current directory exist
+                        switch((u8)dir[file->DirectoryIndex].Name[0])                           // check if current directory exist
-                {
+                        {
-                        case SLOT_EMPTY:
+                                case SLOT_EMPTY:
-                        case SLOT_DELETED:
+                                case SLOT_DELETED:
-                                // the directrory pointer of this file points to a deleted or not existen directory
+                                        // the directrory pointer of this file points to a deleted or not existen directory
-                                // therefore no file or subdirectory exist here
+                                        // therefore no file or subdirectory exist here
-                                return (direntry_exist);
+                                        return(direntry_exist);
-                                break;
+                                        break;
-                        default:        // and is a real directory
+                                default:        // and is a real directory
-                                if((dir[file->DirectoryIndex].Attribute & ATTR_SUBDIRECTORY) != ATTR_SUBDIRECTORY)
+                                        if((dir[file->DirectoryIndex].Attribute & ATTR_SUBDIRECTORY) != ATTR_SUBDIRECTORY)
-                                {       // current file is not a directory therefore no file or subdirectory can be created here
+                                        {       // current file is not a directory therefore no file or subdirectory can be searched here
-                                        return (direntry_exist);
+                                                return(direntry_exist);
-                                }
+                                        }
+                                        break;
-                                break;
+                        }
+                        // check that search area matches directory entry
+                        if(file->FirstSectorOfFirstCluster != Fat16ClusterToSector(dir[file->DirectoryIndex].StartCluster))
+                        {
+                                return (direntry_exist);
+                        }
+                } */
+        }
-                file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dir[file->DirectoryIndex].StartCluster);
+        else return (direntry_exist); // bad sector range for search area
         // update current file data area position to start of first cluster
         file->FirstSectorOfCurrCluster  = file->FirstSectorOfFirstCluster;
                         curr_sector = file->FirstSectorOfCurrCluster + dir_sector;      // calculate sector number
                         file->SectorInCache = curr_sector;                                                      // upate the sector number of file cache.
                         if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read the sector
+                        {
                                 Fat16_Deinit();
-                                return(0);
+                                return(direntry_exist);
+                        }
                         dir = (DirEntry_t *)file->Cache;                                                        // set pointer to directory
                         // search all directory entries within that sector
                         for(dir_entry = 0; dir_entry < DIRENTRIES_PER_SECTOR; dir_entry++)
                         {   // check for existing dir entry
                 // if we are seaching in the data area and the file not found in this cluster so take next cluster.
                 if(!direntry_exist && ( Partition.FirstDataSector <= file->FirstSectorOfCurrCluster))
+                {
                         end_of_directory_not_reached = GetNextCluster(file);  // updates File->FirstSectorOfCurrCluster
+                }
-        }while((end_of_directory_not_reached) && (!direntry_exist)); // repeat until a next cluster exist an no
+        }while((end_of_directory_not_reached) && (!direntry_exist)); // repeat until a next cluster exist an no match has been found
         return(direntry_exist);
+}
         u16 end_of_directory_not_reached = 0;
         u8      i                       = 0;
         u8      retvalue        = 0;
         DirEntry_t *dir;
+        // incomming pointers are useless?
-        if((!Partition.IsValid) || (file == NULL) || (dirname == NULL)) return (retvalue);
-        // It is not checked here that the dir entry that should be created is already existent!
+        if((!Partition.IsValid) || (file == NULL) || (dirname == NULL)) return(retvalue);
-        // Dir entries can be created only in file-clusters that have
-        // the dir-flag set in its attribute or within the root directory
+        // check sector range to be searched
-        file->FirstSectorOfFirstCluster = SECTOR_UNDEFINED;
-        // no current directory exist therefore assume creating in the root
-        if(file->DirectorySector == SECTOR_UNDEFINED)
-        {
-                max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
-                dircluster = 0;
-                file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
-        }
-        // within the root directory area we can read sectors sequentially until the end of this area
-        else if((Partition.FirstRootDirSector <= file->DirectorySector) && (file->DirectorySector < Partition.FirstDataSector))
+        // no creation area defined?
-        {
-                max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
+        if(file->FirstSectorOfFirstCluster == SECTOR_UNDEFINED)
-                dircluster = 0;
+        {
-                file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
+                return(retvalue);
+        }
-        // within the data clusters we can read sectors sequentially only within the cluster
+        //is creation area the root?
-        else if((Partition.FirstDataSector <= file->DirectorySector) && (file->DirectorySector <= Partition.LastDataSector))
+        else if(Partition.FirstRootDirSector == file->FirstSectorOfFirstCluster)
+        {
-                max_dir_sector = Partition.SectorsPerCluster;
-                file->FirstSectorOfFirstCluster = Partition.CurrentWorkingDirectory;
+                max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;  // limit to  size of root
-        }
+                file->DirectorySector = SECTOR_UNDEFINED; // if we have to search within the root, there is no corresponding directory entry available
         else return (retvalue); // bad sector range for directory sector of the file
-        // if search area is not defined yet
+        // is creation area within the data cluster range?
-        if(file->FirstSectorOfFirstCluster == SECTOR_UNDEFINED)
+        else if((Partition.FirstDataSector <= file->FirstSectorOfFirstCluster) && (file->FirstSectorOfFirstCluster <= Partition.LastDataSector))
         {
-            // check if the directory entry of current file is existent and has the dir-flag set
+                max_dir_sector = Partition.SectorsPerCluster;                                   // limit max sectors before next cluster
-                file->SectorInCache = file->DirectorySector;                            // update the sector number of file cache.
-                if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
+                // there must be a corresponding directory entry
                 if(file->DirectorySector == SECTOR_UNDEFINED)
-                        Fat16_Deinit();
+                {
-                        return(0);
                         return (retvalue);
+                }
+                else // check directory entry
+                {
+                        file->SectorInCache = file->DirectorySector;                            // update the sector number of file cache.
+                        if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache)) // read in the sector.
+                        {
+                                Fat16_Deinit();
+                                return (retvalue);
+                        }
-                dir = (DirEntry_t *)file->Cache;                                                        // set pointer to directory
+                        dir = (DirEntry_t *)file->Cache;                                                        // set pointer to directory
-                switch((u8)dir[file->DirectoryIndex].Name[0])                           // check if current directory exist
+                        switch((u8)dir[file->DirectoryIndex].Name[0])                           // check if current directory exist
+                        {
+                                case SLOT_EMPTY:
-                {
+                                case SLOT_DELETED:
-                        case SLOT_EMPTY:
+                                        // the directrory pointer of this file points to a deleted or not existen directory
-                        case SLOT_DELETED:
+                                        // therefore no file or subdirectory exist here
-                                return (retvalue);
+                                        return(retvalue);
-                                break;
+                                        break;
-                        default:        // and is a real directory
+                                default:        // and is a real directory
-                                if((dir[file->DirectoryIndex].Attribute & ATTR_SUBDIRECTORY) != ATTR_SUBDIRECTORY)
+                                        if((dir[file->DirectoryIndex].Attribute & ATTR_SUBDIRECTORY) != ATTR_SUBDIRECTORY)
-                                {       // current file is not a directory therefore no file or subdirectory can be created here
+                                        {       // current file is not a directory therefore no file or subdirectory can be created here
+                                                return(retvalue);
+                                        }
+                                        break;
+                        }
+                        // check that search area matches directory entry
+                        if(file->FirstSectorOfFirstCluster != Fat16ClusterToSector(dir[file->DirectoryIndex].StartCluster))
                                         return (retvalue);
-                                }
-                                break;
                                 return (retvalue);
+                        }
-                dircluster = dir[file->DirectoryIndex].StartCluster;
+                }
                 file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dircluster);
         else return(retvalue); // bad sector range for search area
-        // if the new direntry is a subdirectory
+        // if the new directory entry is a subdirectory
         if((attrib & ATTR_SUBDIRECTORY) == ATTR_SUBDIRECTORY)
                         curr_sector = file->FirstSectorOfCurrCluster + dir_sector;      // calculate sector number
                         file->SectorInCache = curr_sector;                                                      // update the sector number of file cache.
                         if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
+                        {
                                 Fat16_Deinit();
-                                return(0);
+                                return(retvalue);
+                        }
                         dir = (DirEntry_t *)file->Cache;                                                        // set pointer to directory
                         // search all directory entries of a sector
                                         dir[dir_entry].StartCluster = subdircluster;                                            // copy the location of the first datacluster to the directoryentry.
                                         dir[dir_entry].Size             = 0;                                                                    // the new createted file has no content yet.
                                         if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))       // write back to card
+                                        {
                                                 Fat16_Deinit();
-                                                return(0);
+                                                return(retvalue);
+                                        }
                                         file->FirstSectorOfFirstCluster = Fat16ClusterToSector(subdircluster);  // Calculate absolute sectorposition of first datacluster.
                                         file->FirstSectorOfCurrCluster  = file->FirstSectorOfFirstCluster;      // Start reading the file with the first sector of the first datacluster.
                                         file->SectorOfCurrCluster               = 0;                                                            // reset sector of cureen cluster
                                         file->ByteOfCurrSector                  = 0;                                                            // reset the byte location within the current sector
                                                 ClearCurrCluster(file); // fill cluster with zeros
                                                 file->SectorInCache = file->FirstSectorOfFirstCluster;
                                                 if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
+                                                {
                                                         Fat16_Deinit();
-                                                        return(0);
+                                                        return(retvalue);
+                                                }
                                                 dir = (DirEntry_t *)file->Cache;
                                                 // create direntry "." to current dir
                                                 dir[0].Name[0] = 0x2E;
                                                 for(i = 1; i < 11; i++) dir[0].Name[i] = ' ';
                                                 dir[1].StartCluster = dircluster;
                                                 dir[1].Size = 0;
                                                 if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))// read in the sector.
+                                                {
                                                         Fat16_Deinit();
-                                                        return(0);
+                                                        return(retvalue);
+                                                }
+                                        }
                                         retvalue = 1;
                                         dir_entry = DIRENTRIES_PER_SECTOR;      // stop for-loop
+                                }
+{
         DirEntry_t *DirectoryEntry = NULL;
         u8 retval = 0;
+        if((!Partition.IsValid) || (file == NULL)) return (retval);
+        // valid directory sector?
-        if((!Partition.IsValid) || (file == NULL)) return (retval);
+        if((Partition.FirstRootDirSector <= file->DirectorySector) && (file->DirectorySector < Partition.LastDataSector))
+        {
-        // try to  read the sector containing the directoryentry of the file to be deleted
+                // try to  read the sector containing the directory entry of the file to be deleted
-        if(SD_SUCCESS != SDC_GetSector((u32) file->DirectorySector,file->Cache)) return(retval);
+                if(SD_SUCCESS != SDC_GetSector((u32) file->DirectorySector,file->Cache)) return(retval);
-        // get access to the elements of the directoryentry
+                // get access to the elements of the directoryentry
-        DirectoryEntry = (DirEntry_t *)file->Cache;
+                DirectoryEntry = (DirEntry_t *)file->Cache;
-        // delete the directoryentry
+                // delete the directoryentry
-        DirectoryEntry[file->DirectoryIndex].Name[0] = SLOT_DELETED;
+                DirectoryEntry[file->DirectoryIndex].Name[0] = SLOT_DELETED;
-        DirectoryEntry[file->DirectoryIndex].Attribute = 0;
+                DirectoryEntry[file->DirectoryIndex].Attribute = 0;
-        DirectoryEntry[file->DirectoryIndex].Size = 0;
+                DirectoryEntry[file->DirectoryIndex].Size = 0;
-        // the file has been deleted from the directory, save the modified sector back to the filesystem
+                // the file has been deleted from the directory, save the modified sector back to the filesystem
+                if(SD_SUCCESS == SDC_PutSector((u32) file->DirectorySector,file->Cache)) retval = 1;
         if(SD_SUCCESS == SDC_PutSector((u32) file->DirectorySector,file->Cache)) retval = 1;
         return(retval);
+}
         // if incomming pointers are useless return immediatly
         if ((filename == NULL) || (file == NULL) || (!Partition.IsValid)) return 0;
         // trace along the filepath
         path = (s8*)filename;                                                           // start at the beginning of the filename string
-        file->DirectoryIndex = 0;
+        file->DirectoryIndex = 0;                                                       // start search at first dir entry of cluster
         if(path[0] == '/') // if a path begins  with a '/' the search starts at RootDirectory with file search
         {
-                file->DirectorySector = Partition.FirstRootDirSector;   // start at RootDirectory with file search
+                file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;         // start at RootDirectory with file search
+        }
         else // if a path begins not with a '/' the search starts relative to the CWD
         {
-                file->DirectorySector = Partition.CurrentWorkingDirectory;
+                file->FirstSectorOfFirstCluster = Partition.CurrentWorkingDirectory;
+        }
         // as long as the file was not found and the remaining path is not empty
         while((*path != 0) && !file_exist)
         {       // separate dirname and subpath from filepath string
                                 af = ATTR_SUBDIRECTORY;
                                 am = ATTR_SUBDIRECTORY|ATTR_VOLUMELABEL;
+                        }
                         if(!DirectoryEntryExist(dirname, af, am, file))
+                        {
-                                return (file_exist); // subdirectory does not exist
+                                return(file_exist); // subdirectory does not exist
+                        }
                         else
+                        {
                                 if (*subpath == 0)
+                                {
+                                }
+                        }
+                }
                 else // error seperating the subpath
+                {
-                        return file_exist; // bad subdir format
+                        return(file_exist); // bad subdir format
+                }
                 path = subpath;
                 subpath = 0;
+        }
-        return (file_exist);
+        return(file_exist);
+}
+{
         s8 *path = 0;
         s8 *subpath = 0;
         u8 af, am, file_created = 0;
         s8 dirname[12];
+        s8 txt[60];
+        u8 i=0;
         // if incomming pointers are useless return immediatly
         if ((filename == NULL) || (file == NULL) || (!Partition.IsValid)) return(0);
         // trace along the filepath
         path = (s8*)filename;
         if(path[0] == '/') // if a path begins  with a '/' the search starts at RootDirectory with file search
+        {
-                file->DirectorySector = Partition.FirstRootDirSector;   // start at RootDirectory with file search
+                file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;         // start at RootDirectory with file search
         }
         else // if a path begins not with a '/' the search starts relative to the CWD
+        {
-                file->DirectorySector = Partition.CurrentWorkingDirectory;
+                file->FirstSectorOfFirstCluster = Partition.CurrentWorkingDirectory;
+        }
                                 {       // could not be created
                                         return(file_created);
+                                }
                                 else if(*subpath == 0) file_created = 1; // last element of path chain was created
+                        }
+                        sprintf(txt+i, "s:%06d",file->FirstSectorOfFirstCluster);
+                        i+=8;
+                }
                 else // error seperating the subpath
+                {
-                        return file_created; // bad subdir format
+                        return(file_created); // bad subdir format
+                }
                 path = subpath;
                 subpath = NULL;
+        }
+        Debug(txt);
-        return (file_created);
+        return(file_created);
+}
         File_t file;
         if(filepath == NULL) return(0);
         // correct filepath formatting
+        Slashing_Path(filepath);
+        file.FirstSectorOfFirstCluster = SECTOR_UNDEFINED;              // First sector of the first cluster of the file.
+        file.FirstSectorOfCurrCluster = SECTOR_UNDEFINED;               // First sector of the cluster which is edited at the moment.
+        file.FirstSectorOfLastCluster = SECTOR_UNDEFINED;               // First sector of the last cluster of the file
+        file.SectorOfCurrCluster = SECTOR_UNDEFINED;                    // The sector within the current cluster.
+        file.ByteOfCurrSector = 0;                                                              // The byte location within the current sector.
+        file.Mode = 0;                                                                                  // Mode of fileoperation (read,write)
+        file.Size = 0;                                                                                  // The size of the opend file in bytes.
+        file.Position = 0;                                                                              // Pointer to a character within the file 0 < fileposition < filesize
+        file.DirectorySector = SECTOR_UNDEFINED;                                // the sectorposition where the directoryentry has been made.
+        file.DirectoryIndex = 0;                                                                // The index to the directoryentry within the specified sector.
+        file.Attribute = 0;                                                                             // The attribute of the file opened.
+        file.SectorInCache = SECTOR_UNDEFINED;                                  // The last sector read, which is still in the sector cache.
+        file.State = FSTATE_USED;                                                               // mark it as used
         Slashing_Path(filepath);
         // if file is existent
         if(FileExist(filepath, ATTR_NONE, ATTR_SUBDIRECTORY|ATTR_VOLUMELABEL, &file))
+        {
                 // and is not marked as readonly?
+                {
                         retvalue = 0;
                         // we have modified the result of the findfirst_ operation therefore we have to redo findfirst_ to get detailed infos about the directory entry to be deleted
                         if(findfirst_(dn, 0xff, &fe))
+                        {
+                                Debug("found");
                                 // try to clear the allocated clusters within the fat
                                 if(DeleteClusterChain(fe.fp.FirstSectorOfFirstCluster))
+                                {
                                         // delete the directoryentry within the specified directory
                                         if(DeleteDirectoryEntry(&(fe.fp))) retvalue = 1;
         File_t file;
         if(dirpath == NULL) return(0);
         // correct filepath formatting
+        Slashing_Path(dirpath);
+        file.FirstSectorOfFirstCluster = SECTOR_UNDEFINED;              // First sector of the first cluster of the file.
+        file.FirstSectorOfCurrCluster = SECTOR_UNDEFINED;               // First sector of the cluster which is edited at the moment.
+        file.FirstSectorOfLastCluster = SECTOR_UNDEFINED;               // First sector of the last cluster of the file
+        file.SectorOfCurrCluster = SECTOR_UNDEFINED;                    // The sector within the current cluster.
+        file.ByteOfCurrSector = 0;                                                              // The byte location within the current sector.
+        file.Mode = 0;                                                                                  // Mode of fileoperation (read,write)
+        file.Size = 0;                                                                                  // The size of the opend file in bytes.
+        file.Position = 0;                                                                              // Pointer to a character within the file 0 < fileposition < filesize
+        file.DirectorySector = SECTOR_UNDEFINED;                                // the sectorposition where the directoryentry has been made.
+        file.DirectoryIndex = 0;                                                                // The index to the directoryentry within the specified sector.
+        file.Attribute = 0;                                                                             // The attribute of the file opened.
+        file.SectorInCache = SECTOR_UNDEFINED;                                  // The last sector read, which is still in the sector cache.
-        Slashing_Path(dirpath);
+        file.State = FSTATE_USED;                                                               // mark it as used
         // if directory is not existent
         if(!FileExist(dirpath, ATTR_SUBDIRECTORY, ATTR_SUBDIRECTORY|ATTR_VOLUMELABEL, &file))
+        {
                 retvalue = FileCreate(dirpath, ATTR_SUBDIRECTORY, &file);

Subversion Repositories NaviCtrl

(root)/tags/V2.16a/fat16.c @ 796 - Rev 427 → 431