WebSVN - NaviCtrl - Diff - Rev 407 and 427

 // + www.MikroKopter.com
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Software Nutzungsbedingungen (english version: see below)
 // + der Fa. HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland - nachfolgend Lizenzgeber genannt -
 // + Der Lizenzgeber räumt dem Kunden ein nicht-ausschließliches, zeitlich und räumlich* unbeschränktes Recht ein, die im den
 // + Mikrocontroller verwendete Firmware für die Hardware Flight-Ctrl, Navi-Ctrl, BL-Ctrl, MK3Mag & PC-Programm MikroKopter-Tool
 // + - nachfolgend Software genannt - nur für private Zwecke zu nutzen.
 // + Der Einsatz dieser Software ist nur auf oder mit Produkten des Lizenzgebers zulässig.
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Die vom Lizenzgeber gelieferte Software ist urheberrechtlich geschützt. Alle Rechte an der Software sowie an sonstigen im
 // + Rahmen der Vertragsanbahnung und Vertragsdurchführung überlassenen Unterlagen stehen im Verhältnis der Vertragspartner ausschließlich dem Lizenzgeber zu.
 // + Die in der Software enthaltenen Copyright-Vermerke, Markenzeichen, andere Rechtsvorbehalte, Seriennummern sowie
 // + sonstige der Programmidentifikation dienenden Merkmale dürfen vom Kunden nicht verändert oder unkenntlich gemacht werden.
 // + Der Kunde trifft angemessene Vorkehrungen für den sicheren Einsatz der Software. Er wird die Software gründlich auf deren
 // + Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.
 // + Die Haftung des Lizenzgebers wird - soweit gesetzlich zulässig - begrenzt in Höhe des typischen und vorhersehbaren
 // + Schadens. Die gesetzliche Haftung bei Personenschäden und nach dem Produkthaftungsgesetz bleibt unberührt. Dem Lizenzgeber steht jedoch der Einwand
 // + des Mitverschuldens offen.
 // + Der Kunde trifft angemessene Vorkehrungen für den Fall, dass die Software ganz oder teilweise nicht ordnungsgemäß arbeitet.
 // + Er wird die Software gründlich auf deren Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.
 // + Der Kunde wird er seine Daten vor Einsatz der Software nach dem Stand der Technik sichern.
 // + Der Kunde ist darüber unterrichtet, dass der Lizenzgeber seine Daten im zur Vertragsdurchführung erforderlichen Umfang
 // +  Hinweis: Informationen über erweiterte Nutzungsrechte (wie z.B. Nutzung für nicht-private Zwecke) sind auf Anfrage per Email an info(@)hisystems.de verfügbar.
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Software LICENSING TERMS
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + of HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland, Germany - the Licensor -
 // + The Licensor grants the customer a non-exclusive license to use the microcontroller firmware of the Flight-Ctrl, Navi-Ctrl, BL-Ctrl, and MK3Mag hardware
 // + (the Software) exclusively for private purposes. The License is unrestricted with respect to time and territory*.
 // + The Software may only be used with the Licensor's products.
 // + The Software provided by the Licensor is protected by copyright. With respect to the relationship between the parties to this
 // + agreement, all rights pertaining to the Software and other documents provided during the preparation and execution of this
 // + agreement shall be the property of the Licensor.
 #include "fat16.h"
 #include "sdc.h"
 #include "uart1.h"
 #include "main.h"
 #include "logging.h"
+#include "debug.h"
 //________________________________________________________________________________________________________________________________________
 // Module name:                 fat16.c
 // Compiler used:               avr-gcc 3.4.5
-// Last Modifikation:   20.03.2010
+// Last Modifikation:   1.12.2012
-// Version:                             2.10
+// Version:                             2.11
 // Authors:                             Stephan Busker & Gregor Stobrawa
 // Description:                 Source files for FAT16 implementation with read and write-access
 //                                              Copyright (C) 2008 Stephan Busker & Gregor Stobrawa
 //........................................................................................................................................
 // Functions:                   extern s16              Fat16_Init(void);
+//                                              extern s16              Fat16_Deinit(void);
-//                                              extern s16              Fat16_Deinit(void);
+//                                              extern s8*              FAT16_GetVolumeLabel(void);
-//                                              extern s8*              FAT16_GetVolumeLabel(void);
+//
 //                                              extern File_t * fopen_(const u8 *filename, const s8 mode);
-//                                              extern s16              fclose_(File_t *File);
+//                                              extern s16              fclose_(File_t *file);
 //                                              extern u8               fexist_(s8 * const filename);
-//                                              extern s16              fflush_(File_t *File);
+//                                              extern s16              fflush_(File_t *file);
-//                                              extern s16      fseek_(File_t *File, s32 offset, s16 origin);
+//                                              extern s16      fseek_(File_t *file, s32 offset, s16 origin);
-//                                              extern s16              fgetc_(File_t *File);
+//                                              extern s16              fgetc_(File_t *file);
-//                                              extern s16              fputc_(u8 c, File_t *File);
+//                                              extern s16              fputc_(u8 c, File_t *file);
-//                                              extern u32              fread_(void *buffer, u32 size, u32 count, File_t *File);
+//                                              extern u32              fread_(void *buffer, u32 size, u32 count, File_t *file);
-//                                              extern u32              fwrite_(void *buffer, u32 size, u32 count, File_t *File);
+//                                              extern u32              fwrite_(void *buffer, u32 size, u32 count, File_t *file);
 //                                              extern s16              fputs_(const u8 *string, File_t *File);
+//                                              extern u8 *     fgets_(u8 *string, s16 length, File_t *file);
+//                                              extern u8               feof_(File_t * const file);
+//                                              extern u8               fdelete_(s8* const filepath);
+//
+//                                              extern s8               *getcwd_(void);
+//                                              extern u8               chdir_(s8* const dirpath);
+//                                              extern u8               mkdir_(s8* const dirpath);
+//                                              extern u8               rmdir_(s8* const dirpath);
-//                                              extern u8 *     fgets_(u8 *string, s16 length, File_t *File);
+//                                              extern u8               findfirst_(const s8* name, u8 attribmask, Find_t *);
-//                                              extern u8               feof_(File_t * const file);
+//                                              extern u8               findnext_(Find_t *);
 //........................................................................................................................................
 // ext. functions:              extern SD_Result_t SDC_Init(void;)
 //                                              extern SD_Result_t SDC_Deinit(void);
         u16 StartCluster;                               // first cluster of the file or directory.
         u32 Size;                                               // size of the file or directory in bytes.
 }  __attribute__((packed)) DirEntry_t;
 #define SLOT_EMPTY              0x00    // slot has never been used
-#define SLOT_E5                 0x05    // the real value is 0xe5
+#define SLOT_E5                 0x05    // the real value is 0xE5
-#define SLOT_DELETED            0xE5    // file in this slot deleted
-#define ATTR_NONE               0x00    // normal file
-#define ATTR_READONLY           0x01    // file is readonly
-#define ATTR_HIDDEN                     0x02    // file is hidden
-#define ATTR_SYSTEM                     0x04    // file is a system file
-#define ATTR_VOLUMELABEL        0x08    // entry is a volume label
-#define ATTR_LONG_FILENAME      0x0F    // this is a long filename entry
-#define ATTR_SUBDIRECTORY       0x10    // entry is a directory name
-#define ATTR_ARCHIVE            0x20    // file is new or modified
 #define SLOT_DELETED            0xE5    // file in this slot deleted
 /*
 ________________________________________________________________________________________________________________________________________
         u32 FirstFatSector;                     // sector of the start of the fat
         u32 FirstRootDirSector;         // sector of the rootdirectory
         u32 FirstDataSector;            // sector of the first cluster containing data (cluster2).
         u32 LastDataSector;                     // the last data sector of the partition
         u8  VolumeLabel[12];        // the volume label
         u32     CurrentWorkingDirectory;// A pointer to the directory we are actual using
         s8      PathToCwd[256];                 // a string containing the complete path to the current working directory
 }   __attribute__((packed)) Partition_t;
 Partition_t     Partition;              // Structure holds partition information
+File_t FilePointer[FILE_MAX_OPEN];      // Allocate Memmoryspace for each filepointer used.
+/********************************************************************************************************************************************/
+/*      Function:               s8 *getcwd_(void);                                                                                                                                                                                                              */
+/*                                                                                                                                                                                                                                                                                      */
+/*      Description:    This function returns a pointer to the absolute path of the active partition                                                                            */
+/*                                                                                                                                                                                                                                      */
+/*                                                                                                                                                                                                                                                                                      */
+/*      Returnvalue:    pointer to the string containing the path to the CWD                                                                                                                                    */
+/********************************************************************************************************************************************/
+s8 *getcwd_(void)
+{
+        return(Partition.PathToCwd);
+}
+/********************************************************************************************************************************************/
+/*      Function:               void CWDPath_Push(s8* directory);                                                                                                                                                                               */
+/*                                                                                                                                                                                                                                                                                      */
+/*      Description:    This function function appends the name of an directory to the path of the CWD                                                                                  */
+/*                                                                                                                                                                                                                                      */
+/*                                                                                                                                                                                                                                                                                      */
+/*      Returnvalue:    none                                                                                                                                                                                                                                    */
+/********************************************************************************************************************************************/
+void CWDPath_Push(s8* directory)
+{
+        // append the name of the directory to the path
+        strcat(Partition.PathToCwd, directory);
+        // append a '/' after the directoryname
+        strcat(Partition.PathToCwd, "/");
+}
+/********************************************************************************************************************************************/
+/*      Function:               CWDPath_Pop(void);                                                                                                                                                                                                              */
+/*                                                                                                                                                                                                                                                                                      */
+/*      Description:    This function removes the last directory from the path to the CWD                                                                                                               */
+/*                                                                                                                                                                                                                                      */
+/*                                                                                                                                                                                                                                                                                      */
+/*      Returnvalue:    none                                                                                                                                                                                                                                    */
+/********************************************************************************************************************************************/
+void CWDPath_Pop(void)
+{
+        // a pointer to the beginning of the absolute path to the cwd
+        s8 * cptr = Partition.PathToCwd;
+        // lets find the end of the path to the cwd
+        while(*cptr != 0 ) cptr++;
+        // if the path is terminated with an '/' then remove it
+        if((*(cptr-1)) == '/') *(cptr-1) = 0;
+        // now lets find the beginning of the last directory entry
+        while((*cptr != '/' ) && cptr > Partition.PathToCwd) cptr--;
+        // is there one subdirectory left within the path?
+        if(cptr > Partition.PathToCwd)
+        {
+                // we delete the direntry by terminating the path with 0
+                *(cptr+1) = 0;
+        }
+        // there is no subdirectory left within the path. Therefore we create the root instead.
+        else
+        {
-File_t FilePointer[FILE_MAX_OPEN];      // Allocate Memmoryspace for each filepointer used.
+                *cptr = '/';
                 *(cptr+1) = 0;
+        }
+{
         u8 i;
         File_t * File = 0;
         for(i = 0; i < FILE_MAX_OPEN; i++)
+        {
-                if(FilePointer[i].State == FSTATE_UNUSED)               // found an unused one
+                if(FilePointer[i].State == FSTATE_UNUSED)                                                               // found an unused one
+                {
-                        File = &FilePointer[i];                                         // set pointer to that entry
+                        File = &FilePointer[i];                                                                                         // set pointer to that entry
+                        FilePointer[i].FirstSectorOfFirstCluster = SECTOR_UNDEFINED;            // First sector of the first cluster of the file.
+                        FilePointer[i].FirstSectorOfCurrCluster = SECTOR_UNDEFINED;                     // First sector of the cluster which is edited at the moment.
+                        FilePointer[i].FirstSectorOfLastCluster = SECTOR_UNDEFINED;                     // First sector of the last cluster of the file
+                        FilePointer[i].SectorOfCurrCluster = SECTOR_UNDEFINED;                          // The sector within the current cluster.
+                        FilePointer[i].ByteOfCurrSector = 0;                                                            // The byte location within the current sector.
+                        FilePointer[i].Mode = 0;                                                                                        // Mode of fileoperation (read,write)
+                        FilePointer[i].Size = 0;                                                                                        // The size of the opend file in bytes.
+                        FilePointer[i].Position = 0;                                                                            // Pointer to a character within the file 0 < fileposition < filesize
+                        FilePointer[i].DirectorySector = SECTOR_UNDEFINED;                                      // the sectorposition where the directoryentry has been made.
+                        FilePointer[i].DirectoryIndex = 0;                                                                      // The index to the directoryentry within the specified sector.
+                        FilePointer[i].Attribute = 0;                                                                           // The attribute of the file opened.
+                        FilePointer[i].SectorInCache = SECTOR_UNDEFINED;                                        // The last sector read, which is still in the sector cache.
-                        FilePointer[i].State = FSTATE_USED;                     // mark it as used
+                        FilePointer[i].State = FSTATE_USED;                                                                     // mark it as used
                         break;
+                }
+        }
         return(File);
+}
+        }
         return(0);
+}
 /****************************************************************************************************************************************/
-/*      Function:               SeperateDirName(s8*, s8*);                                                                                                                                                                              */
+/*      Function:               s8* SeperateFormatedDirName(const s8*, s8*);                                                                                                                                            */
 /*                                                                                                                                                                                                                                                                              */
 /*      Description:    This function seperates the first dirname from filepath and brings them                                                                                         */
 /*                                      into the needed format ('test.txt' -> 'TEST    TXT')                                                                                                                            */
 /*                                      The subpath is the pointer to the remaining substring of the filepath                                                                                           */
 /*                                                                                                                                                                                                                                                                              */
-/*      Returnvalue:    Return NULL on error or pointer to subpath                                                                                                                                                                                                      */
+/*      Returnvalue:    Return NULL on error or pointer to subpath                                                                                                                                                      */
 /****************************************************************************************************************************************/
-s8* SeperateDirName(const s8 *filepath, s8 *dirname)
+s8* SeperateFormatedDirName(const s8 *filepath, s8 *dirname)
+{
         s8* subpath = NULL;
         u8 readpointer  = 0;
         for(writepointer = 0; writepointer < 11; writepointer++) dirname[writepointer] = ' ';
         // handle the special dirnames "." and ".." seperately
         readpointer = 0;
         if(filepath[0] == '/') readpointer++;
         // if we are trying to enter directories "." or ".."
         if(filepath[readpointer] == '.')
+        {
                 // directory '.'
                 if(filepath[readpointer+1] == 0)
+                {
                         dirname[0] = '.';
                         return((s8*)&filepath[readpointer]);
                 }
                 // directory '..'
                 if((filepath[readpointer+1] == '.') &&  (filepath[readpointer+2] == 0))
+                {
                         dirname[0] = '.';
                         dirname[1] = '.';
                         return((s8*)&filepath[readpointer]);
+                }
+        }
         return(subpath);
+}
 /**************************************************************************************************************************************+*/
 /*      Function:       Fat16ClusterToSector( u16 cluster);                                                                                                                                                                             */
 /*                                                                                                                                                                                                                                                                              */
 /*      Description:    This function converts a cluster number given by the fat to the corresponding                                                                           */
         u8 cnt;
         UART1_PutString("\r\n FAT16 deinit...");
         // declare the filepointers as unused.
         for(cnt = 0; cnt < FILE_MAX_OPEN; cnt++)
+        {
                 UnlockFilePointer(&FilePointer[cnt]);
+        }
         returnvalue = SDC_Deinit();                     // uninitialize interface to sd-card
         Partition.IsValid = 0;  // mark data in partition structure as invalid
         if(SD_WatchDog > 2000) SD_WatchDog = 2000;
         SD_LoggingError = 100;
         return(returnvalue);
+}
 /****************************************************************************************************************************************/
 /*      Function:               Fat16_Init(void);                                                                                                                                                                                                       */
 /*                                                                                                                                                                                                                                                                          */
 /*      Description:    This function reads the Masterbootrecord and finds the position of the Volumebootrecord, the FAT and the Rootdir    */
                 result = 6;
                 goto end;
+        }
         Partition.IsValid = 1; // mark data in partition structure as valid
         Partition.CurrentWorkingDirectory = Partition.FirstRootDirSector;
         strcpy(Partition.PathToCwd,"/");
         result = 0;
         end:
         if(result != 0) Fat16_Deinit();
         else UART1_PutString("ok");
         return(result);
         u32 i;
         if((!Partition.IsValid) || (file == NULL)) return(0);
         for(i = 0; i < BYTES_PER_SECTOR; i++) file->Cache[i] = 0; // clear file cache
         if(file->FirstSectorOfCurrCluster == SECTOR_UNDEFINED) return (0); // nothing to do
         for(i = 0; i < Partition.SectorsPerCluster; i++)
+        {
                 file->SectorInCache = file->FirstSectorOfCurrCluster + i;
         // repeat until the end of the fat is  reached and no free cluster has been found so far
         }while((fat_sector < Partition.SectorsPerFat) && (!free_cluster));
         return(free_cluster);
+}
-/****************************************************************************************************************************************************/
-/* Function:    s16 fseek_(File_t *, s32 *, u8)                                                                                                                                                                                                         */
-/*                                                                                                                                                                                                                                                                                                      */
-/* Description: This function sets the pointer of the stream relative to the position                                                                                                                           */
-/*                              specified by origin (SEEK_SET, SEEK_CUR, SEEK_END)                                                                                                                                                                      */
-/* Returnvalue: Is 0 if seek was successful                                                                                                                                                                                                                     */
-/****************************************************************************************************************************************************/
-s16 fseek_(File_t *file, s32 offset, s16 origin)
-{
-        s32             fposition       = 0;
-        s16     retvalue        = 1;
-        // the byteindex within a sector
-        u32             byte_index       = 0;
-        // the  sectorindex within a cluster
-        u32             sector_index  = 0;
-        // the index of the cluster within the clusterchain inside the fat
-        u32     cluster_index = 0;
-        // check if the partition is valid
-        if((!Partition.IsValid) || (file == NULL)) return(retvalue);
-//......................................................
-        if(origin == SEEK_SET)                                                                                                          // Fileposition relative to the beginning of the file.
-        {
-                fposition = 0;
-        }
-//......................................................
-        else if(origin == SEEK_END)                                                                                                     // Fileposition relative to the end of the file.
-        {
-                fposition  = (s32) file->Size;
-        }
-//......................................................
-        else if(origin == SEEK_CUR)                                                                                                     // Fileposition relative to the current position of the file.
-        {
-                fposition = (s32)file->Position;
-        }
-        // calculate the specified fileposition according to the selected mode
-        fposition += offset;                                                                                                            // Die Absolute Dateiposition welche durch fseek angesprungen werden soll.
-        // is the fileposition within the file?
-        if((fposition >= 0) && (fposition <= (s32)file->Size))                                          // Ist die berechnete Dateiposition innerhalb der geöffneten Datei?
-        {
-                // initialize the filepointer
-                file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
-                file->SectorOfCurrCluster       = 0;
-                file->ByteOfCurrSector          = 0;
-                file->Position                          = 0;
-                // has the specified file at least one valid sector attached?
-                if(file->FirstSectorOfCurrCluster == SECTOR_UNDEFINED) return(retvalue);
-                // calculate the absolute number of the sector wich contains the fileposition we are looking for
-                sector_index = (u32) ((u32)fposition >> 9);
-                // calculate the index of the cluster containing the specified sector
-                cluster_index = (u32) sector_index / Partition.SectorsPerCluster;
-                // the absolute sectornumber becomes relative to the beginning of the specified cluster
-                sector_index = (sector_index % Partition.SectorsPerCluster);
-                // calculate the index of the byteposition the fileposition points to
-                byte_index = (u32) fposition % 512;
-                // parse the fat till the calculated cluster has been reached
-                while(cluster_index--) GetNextCluster(file);
-                // set the filepointer to the specified sector and byteposition
-                file->SectorOfCurrCluster = (u8) sector_index;
-                file->ByteOfCurrSector = (u16) byte_index;
-                // the fileposition now equals the filepointer
-                file->Position = (u32)fposition;
-                // the specified fileposition has been reached
-                retvalue = 0;
-        }
-        return(retvalue);
-}
 /****************************************************************************************************************************************/
-/* Function:    u16 DeleteClusterChain(File *file);                                                                                                                                                                             */
+/* Function:    u8 DeleteClusterChain(File *file);                                                                                                                                                                              */
 /*                                                                                                                                                                                                                                                                              */
 /* Description: This function trances along a cluster chain in the fat and frees all clusters visited.                                                                  */
+/*                                                                                                                                                                                                                                                                              */
-/*                                                                                                                                                                                                                                                                              */
+/* Returnvalue: returns 1 in success otherwise 0                                                                                                                                                                                */
 /****************************************************************************************************************************************/
 u8 DeleteClusterChain(u16 StartCluster)
+{
         u16 cluster;
         u8 buffer[BYTES_PER_SECTOR];
         u32 sector_in_buffer = 0;
         u8 repeat = 0;
         if(!Partition.IsValid) return(0);
-        if(StartCluster == CLUSTER_UNDEFINED) return(0);
+        if(StartCluster == CLUSTER_UNDEFINED) return(1);
         cluster = StartCluster; // init chain trace
         // if start cluster is no real cluster
-    if(FAT16_CLUSTER_LAST_MIN <= cluster) return 1;
+    if(FAT16_CLUSTER_LAST_MIN <= cluster) return(1);
         // calculate byte offset in the fat for corresponding entry
         fat_byte_offset = ((u32)cluster)<<1; // two FAT bytes (16 bits) for every cluster
 /*                                                                                                                                                                                                                                                                              */
 /* Description: This function looks in the fat to find the next free cluster and appends it to the file.                                                                */
 /*                                                                                                                                                                                                                                                                              */
 /* Returnvalue: The function returns the appened cluster number or CLUSTER_UNDEFINED of no cluster was appended.                                                */
 /****************************************************************************************************************************************/
 u16 AppendCluster(File_t *file)
+{
         u16 last_cluster, new_cluster = CLUSTER_UNDEFINED;
         u32 fat_byte_offset, sector, byte;
         Fat16Entry_t * fat;
         if((!Partition.IsValid) || (file == NULL)) return(new_cluster);
         new_cluster = FindNextFreeCluster(file);        // the next free cluster found on the disk.
+        if(new_cluster != CLUSTER_UNDEFINED)
+        {       // A free cluster was found and can be added to the end of the file.
+                // is there at least one cluster appended to the file?
-        if(new_cluster != CLUSTER_UNDEFINED)
+                if(file->FirstSectorOfLastCluster == CLUSTER_UNDEFINED)
+                {
+                        fseek_(file, 0, SEEK_END);                                                                                                      // jump to the end of the file
-        {       // A free cluster was found and can be added to the end of the file.
+                        // remember the first sector of the last cluster
+                        file->FirstSectorOfLastCluster = file->FirstSectorOfCurrCluster;
+                        last_cluster = SectorToFat16Cluster(file->FirstSectorOfCurrCluster);            // determine current file cluster
+                }
+                else
+                {
+                        last_cluster = SectorToFat16Cluster(file->FirstSectorOfLastCluster);            // determine current file cluster
                 fseek_(file, 0, SEEK_END);                                                                                                      // jump to the end of the file
                 last_cluster = SectorToFat16Cluster(file->FirstSectorOfCurrCluster);            // determine current file cluster
                 if(last_cluster != CLUSTER_UNDEFINED)
+                {
                         // update FAT entry of last cluster
                         if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))               // save the modified sector to the FAT.
+                        {
                                 Fat16_Deinit();
                                 return(0);
+                        }
+                        // now the new cluster appended to the fat is the last cluster
+                        file->FirstSectorOfLastCluster = Fat16ClusterToSector(new_cluster);
+                }
                 else // last cluster of the file is undefined
                 {   // then the new cluster must be the first one of the file
                     // and its cluster number must be set in the direntry
                         DirEntry_t * dir;
+                        }
                         dir = (DirEntry_t *)file->Cache;                                                        // set pointer to directory
                         dir[file->DirectoryIndex].Res1 = 0;
                         dir[file->DirectoryIndex].Res2[0] = 0;
                         dir[file->DirectoryIndex].Res2[1] = 0;
                         dir[file->DirectoryIndex].StartCluster = new_cluster;           // update startcluster
                     dir[file->DirectoryIndex].ModTime   = FileTime(&SystemTime);// set time
                         dir[file->DirectoryIndex].ModDate       = FileDate(&SystemTime);// and date of modification
                         dir[file->DirectoryIndex].LastAccessDate = dir[file->DirectoryIndex].ModDate;
                         dir[file->DirectoryIndex].Size          = 0;
                         // write sector containing the direntry
                         if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))
+                        {
                                 Fat16_Deinit();
                                 return(CLUSTER_UNDEFINED);
+                        }
                         // update file info
                         file->FirstSectorOfFirstCluster = Fat16ClusterToSector(new_cluster);
+                        file->FirstSectorOfLastCluster = file->FirstSectorOfFirstCluster;
                         file->Size = 0;
                         file->Position = 0;
+                }
                 // update file pointes
                 file->FirstSectorOfCurrCluster = Fat16ClusterToSector(new_cluster);
         // if incomming pointers are useless return immediatly
         if((!Partition.IsValid) || (file == NULL) || (dirname == NULL)) return(direntry_exist);
         // dir entries can be searched only in filesclusters that have
-        // a corresponding dir entry with adir-flag set in its attribute
+        // 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
+        }
         // 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))
+        {
                 max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
+                file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
+        }
         // within the data clusters we can read sectors sequentially only within the cluster
         else if((Partition.FirstDataSector <= file->DirectorySector) && (file->DirectorySector <= Partition.LastDataSector))
+        {
-                max_dir_sector = Partition.SectorsPerCluster;                           // limit max secters 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
+        // 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.
                 if(SD_SUCCESS != SDC_GetSector(file->SectorInCache, file->Cache))// read in the sector.
                 switch((u8)dir[file->DirectoryIndex].Name[0])                           // check if current directory exist
+                {
                         case SLOT_EMPTY:
                         case SLOT_DELETED:
                                 // the directrory pointer of this file points to a deleted or not existen directory
-                                // therefore no file or subdirectory can be created
+                                // therefore no file or subdirectory exist here
                                 return (direntry_exist);
                                 break;
                         default:        // and is a real directory
                                 if((dir[file->DirectoryIndex].Attribute & ATTR_SUBDIRECTORY) != ATTR_SUBDIRECTORY)
                                 {       // current file is not a directory therefore no file or subdirectory can be created here
+                                }
                                 break;
+                }
                 file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dir[file->DirectoryIndex].StartCluster);
+        }
         // update current file data area position to start of first cluster
         file->FirstSectorOfCurrCluster  = file->FirstSectorOfFirstCluster;
         file->SectorOfCurrCluster               = 0;
         file->ByteOfCurrSector                  = 0;
+        }
         // 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))
+        {
                 max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
+                dircluster = 0;
+                file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
+        }
         // within the data clusters we can read sectors sequentially only within the cluster
         else if((Partition.FirstDataSector <= file->DirectorySector) && (file->DirectorySector <= Partition.LastDataSector))
+        {
                 max_dir_sector = Partition.SectorsPerCluster;
+                file->FirstSectorOfFirstCluster = Partition.CurrentWorkingDirectory;
+        }
         else return (retvalue); // bad sector range for directory sector of the file
         // if search area is not defined yet
         if(file->FirstSectorOfFirstCluster == SECTOR_UNDEFINED)
+        {
                 file->FirstSectorOfFirstCluster = Fat16ClusterToSector(dircluster);
+        }
         // if the new direntry is a subdirectory
         if((attrib & ATTR_SUBDIRECTORY) == ATTR_SUBDIRECTORY)
-        {       // get a free clutser for its content
+        {       // get a free cluster for its content
                 subdircluster = FindNextFreeCluster(file);      // get the next free cluster on the disk and mark it as used.
+        }
         else // a normal file
         {       // has no data cluster after creation
+        {
                 dir_sector = 0; // reset sector counter within a new cluster
                 do // loop over all sectors of a cluster or all sectors of the root directory
+                {
                         curr_sector = file->FirstSectorOfCurrCluster + dir_sector;      // calculate sector number
-                        file->SectorInCache = curr_sector;                                                      // upate the sector number of file cache.
+                        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);       // return 1 if file has been created otherwise return 0.
+}
+/********************************************************************************************************************************************/
+/*      Function:               u8 DeleteDirectoryEntry(File_t *file)                                                                                                                                                                   */
+/*      Description:    This function deletes the directoryentry of the file to be deleted from the filesystem                                                                  */
+/*                                                                                                                                                                                                                                      */
+/*                                                                                                                                                                                                                                                                                      */
+/*      Returnvalue:    1 on succes and 0 on error                                                                                                                                                                                              */
+/********************************************************************************************************************************************/
+u8 DeleteDirectoryEntry(File_t *file)
+{
+        DirEntry_t *DirectoryEntry = NULL;
+        u8 retval = 0;
+        if((!Partition.IsValid) || (file == NULL)) return (retval);
+        // try to  read the sector containing the directoryentry of the file to be deleted
+        if(SD_SUCCESS != SDC_GetSector((u32) file->DirectorySector,file->Cache)) return(retval);
+        // get access to the elements of the directoryentry
+        DirectoryEntry = (DirEntry_t *)file->Cache;
+        // delete the directoryentry
+        DirectoryEntry[file->DirectoryIndex].Name[0] = SLOT_DELETED;
+        DirectoryEntry[file->DirectoryIndex].Attribute = 0;
+        DirectoryEntry[file->DirectoryIndex].Size = 0;
+        // 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;
+        return(retval);
+}
 /********************************************************************************************************************************************/
 /*      Function:               FileExist(const s8* filename, u8 attribfilter, u8 attribmask, File_t *file);                                                                                    */
 /*                                                                                                                                                                                                                                                                                      */
-/*      Description:    This function looks for the specified file including its subdirectories beginning                                                                               */
-/*                                      in the rootdirectory of the drive. If the file is found the Filepointer properties are                                                                  */
+/*      Description:    This function looks for the specified file including its subdirectories.                                                                                                */
-/*                                      updated.                                                                                                                                                                                                                                */
+/*                  If the file is found the Filepointer properties are updated.                                                                                                                        */
 /*                                                                                                                                                                                                                                                                                      */
 /*      Returnvalue:    1 if file is found else 0.                                                                                                                                                                                              */
 /********************************************************************************************************************************************/
         // if incomming pointers are useless return immediatly
         if ((filename == NULL) || (file == NULL) || (!Partition.IsValid)) return 0;
-        // trace along the filepath
-        path = (s8*)filename;                                                           // start a the beginning of the filename string
+        // trace along the filepath
-        file->DirectorySector = 0;                                                              // start at RootDirectory with file search
+        path = (s8*)filename;                                                           // start at the beginning of the filename string
+        file->DirectoryIndex = 0;
+        if(path[0] == '/') // if a path begins  with a '/' the search starts at RootDirectory with file search
+        {
-        file->DirectoryIndex = 0;
+                file->DirectorySector = Partition.FirstRootDirSector;   // start at RootDirectory with file search
         /* if a path begins with a '/' at index 0 the search starts at the rootdirectory otherwise we will start relative to the cwd */
-        if(path[0] != '/')
-        {
-                /* is the current working directory the rootdirectory? */
-                if(Partition.CurrentWorkingDirectory == Partition.FirstRootDirSector) file->DirectorySector = 0;
+        else // if a path begins not with a '/' the search starts relative to the CWD
-                /* otherwise we are working in an subdirectory */
+        {
-                else file->DirectorySector = Partition.CurrentWorkingDirectory;
+                file->DirectorySector = 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
-                subpath = SeperateDirName(path, dirname);
+                subpath = SeperateFormatedDirName(path, dirname);
                 if(subpath != NULL)
+                {
                         if(*subpath == 0)
         s8 *subpath = 0;
         u8 af, am, file_created = 0;
         s8 dirname[12];
         // if incomming pointers are useless return immediatly
-        if ((filename == NULL) || (file == NULL) || (!Partition.IsValid)) return 0;
+        if ((filename == NULL) || (file == NULL) || (!Partition.IsValid)) return(0);
+        // trace along the filepath
+        path = (s8*)filename;
-        // trace along the filepath
+        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
+        }
+        else // if a path begins not with a '/' the search starts relative to the CWD
+        {
-        path = (s8*)filename;                                                                   // start a the beginning of the filename string
+                file->DirectorySector = Partition.CurrentWorkingDirectory;
+        }
-        file->DirectorySector = 0;                                                              // start at RootDirectory with file search
+        file->DirectoryIndex = 0;
         file->DirectoryIndex = 0;
         // as long as the file was not created and the remaining file path is not empty
         while((*path != 0) && !file_created)
         {   // separate dirname and subpath from filepath string
-                subpath = SeperateDirName(path, dirname);
+                subpath = SeperateFormatedDirName(path, dirname);
                 if(subpath != NULL)
+                {
                         if(*subpath == 0)
                         {       // empty subpath indicates last element of dir chain
                                 af = ATTR_NONE;
                                 am = ATTR_SUBDIRECTORY|ATTR_VOLUMELABEL;  // any file that is no subdir or volume label
+                        }
-                        else  // it must be a subdirectory and no volume label
+                        else  // it must be a subdirectory but no volume label
+                        {
                                 af = ATTR_SUBDIRECTORY;
                                 am = ATTR_SUBDIRECTORY|ATTR_VOLUMELABEL;
                                 if(*subpath == 0) af = attrib; // if last element in dir chain take the given attribute
                                 if(!CreateDirectoryEntry(dirname, af, file))
                                 {       // could not be created
                                         return(file_created);
+                                }
-                                else if (*subpath == 0) file_created = 1; // last element of path chain was created
+                                else if(*subpath == 0) file_created = 1; // last element of path chain was created
+                        }
+                }
                 else // error seperating the subpath
+                {
                         return file_created; // bad subdir format
+                }
                 path = subpath;
-                subpath = 0;
+                subpath = NULL;
+        }
         return (file_created);
+}
+/********************************************************************************************************************************************/
+/*      Function:               void Slashing_Path(s8*)                                                                                                                                                                                                 */
+/*                                                                                                                                                                                                                                                                                      */
+/*      Description:    This function replaces all \ by / in the string pointed to by the argument                                                                              */
+/*                                                                                                                                                                                                                                      */
+/*                                                                                                                                                                                                                                                                                      */
+/*      Returnvalue:                                                                                                                                                                                                                                                    */
+/********************************************************************************************************************************************/
+void Slashing_Path(s8* path)
+{
+        s8 *cptr = path;
+        while(*cptr != 0 )
+        {
+                if(*cptr == '\\') *cptr = '/'; // replace \ by /
+                cptr++;
+        }
+}
 /********************************************************************************************************************************************/
 /*      Function:               File_t * fopen_(s8* filename, s8 mode);                                                                                                                                                                 */
 /*                                                                                                                                                                                                                                                                                      */
 /*      Description:    This function looks for the specified file in the rootdirectory of the drive. If the file is found the number of the    */
-/*                                      corrosponding filepointer is returned. Only modes 'r' (reading) and 'a' append are implemented yet.                                             */
+/*                                      corrosponding filepointer is returned. Only modes 'r' (reading), 'w' (writing) and 'a' (append) are implemented yet.    */
 /*                                                                                                                                                                                                                                                                                      */
 /*      Returnvalue:    The filepointer to the file or 0 if faild.                                                                                                                                                              */
 /********************************************************************************************************************************************/
-File_t * fopen_(s8 * const filename, const s8 mode)
+File_t * fopen_(s8* const filename, const s8 mode)
+{
         File_t *file    = 0;
         file = LockFilePointer();
         // if no unused file pointer was found return 0
         if(file == NULL) return(file);
-        // now we have found a free filepointer and claimed it
-        // so let initiate its property values
-        file->FirstSectorOfFirstCluster = SECTOR_UNDEFINED;             // Sectorpointer to the first sector of the first datacluster of the file.
-        file->FirstSectorOfCurrCluster  = SECTOR_UNDEFINED;             // Pointer to the cluster which is edited at the moment.
-        file->SectorOfCurrCluster               = 0;            // The sector which is edited at the moment (cluster_pointer + sector_index).
-        file->ByteOfCurrSector                  = 0;            // The bytelocation within the current sector (cluster_pointer + sector_index + byte_index).
+        // now we have found a free filepointer and claimed it
-        file->Mode                                              = mode;         // mode of fileoperation (read,write)
-        file->Size                                              = 0;            // the size of the opened file in bytes.
-        file->Position                                  = 0;            // pointer to a byte within the file 0 < fileposition < filesize
-        file->SectorInCache                             = SECTOR_UNDEFINED;             // the last sector read, wich is still in the sectorbuffer.
-        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->Mode                                              = mode;         // mode of fileoperation (read,write)
         file->Attribute                                 = 0;            // the attribute of the file opened.
         // bring the path into the correct syntax
-        // bring the path into the correct syntax
-        cptr = filename;
-        // search the whole string
-        while(*cptr != 0)
-        {
-                // replace all '\' by '/'
-                if(*cptr == '\\') *cptr = '/';
+        Slashing_Path(filename);
-                cptr++;
+        cptr = filename;
         // check if a real file (no directory) to the given filename exist
         if(FileExist(filename, ATTR_NONE, ATTR_SUBDIRECTORY|ATTR_VOLUMELABEL, file))
         {  // file exist
+                                        }
                                         dir = (DirEntry_t *)file->Cache;                                                                // set pointer to directory
                                     dir[file->DirectoryIndex].ModTime   = FileTime(&SystemTime);        // set modification time
                                         dir[file->DirectoryIndex].ModDate       = FileDate(&SystemTime);        // set modification date
                                         dir[file->DirectoryIndex].LastAccessDate = dir[file->DirectoryIndex].ModDate;
                                         dir[file->DirectoryIndex].StartCluster = CLUSTER_UNDEFINED;             // update startcluster
                                         dir[file->DirectoryIndex].Size          = 0;
                                         // write sector containing the direntry
                                         if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))
+                                        {
                                                 Fat16_Deinit();
                                 // try to create the file
                                 if(!FileCreate(filename, ATTR_ARCHIVE, file))
                                 { // if it could not be created
                                         fclose_(file);
                                         file = NULL;
                                 }
                                 break;
                         case 'r': // else opened for 'r'
                         default:  // if unsupported mode
                                 fclose_(file);
                                 file = NULL;
         file = NULL;
         return(file);
+}
+/****************************************************************************************************************************************************/
+/* Function:    s16 fseek_(File_t *, s32 *, u8)                                                                                                                                                                                                         */
+/*                                                                                                                                                                                                                                                                                                      */
+/* Description: This function sets the pointer of the stream relative to the position                                                                                                                           */
+/*                              specified by origin (SEEK_SET, SEEK_CUR, SEEK_END)                                                                                                                                                                      */
+/* Returnvalue: Is 0 if seek was successful                                                                                                                                                                                                                     */
+/****************************************************************************************************************************************************/
+s16 fseek_(File_t *file, s32 offset, s16 origin)
+{
+        s32             fposition       = 0;
+        s16     retvalue        = 1;
+        u32             byte_index       = 0;   // the byteindex within a sector
+        u32             sector_index  = 0;      // the  sectorindex within a cluster
+        u32     cluster_index = 0;      // the index of the cluster within the clusterchain inside the fat
+        // check if the partition is valid
+        if((!Partition.IsValid) || (file == NULL)) return(retvalue);
+        switch(origin)
+        {
+                case SEEK_SET:                          // Fileposition relative to the beginning of the file.
+                        fposition = 0;
+                        break;
+                case SEEK_END:                          // Fileposition relative to the end of the file.
+                        fposition = (s32)file->Size;
+                        break;
+                case SEEK_CUR:                          // Fileposition relative to the current position of the file.
+                default:
+                        fposition = file->Position;
+                        break;
+        }
+        // calculate the specified fileposition according to the selected mode
+        fposition += offset;
+        // is the fileposition within the file?
+        if((fposition >= 0) && (fposition <= (s32)file->Size))
+        {
+                // initialize the filepointer to start of the file
+                file->FirstSectorOfCurrCluster = file->FirstSectorOfFirstCluster;
+                file->SectorOfCurrCluster       = 0;
+                file->ByteOfCurrSector          = 0;
+                file->Position                          = 0;
+                // has the specified file at least one valid sector attached?
+                if(file->FirstSectorOfCurrCluster == SECTOR_UNDEFINED) return(retvalue);
+                // calculate the absolute number of the sector wich contains the fileposition we are looking for
+                sector_index = (u32) ((u32)fposition >> 9);      // 512 bytes per sector
+                // calculate the index of the cluster containing the specified sector
+                cluster_index = (u32) sector_index / Partition.SectorsPerCluster;
+                // the absolute sectornumber becomes relative to the beginning of the specified cluster
+                sector_index = (sector_index % Partition.SectorsPerCluster);
+                // calculate the index of the byteposition the fileposition points to
+                byte_index = (u32) fposition % 512;
+                // parse the fat till the calculated cluster has been reached
+                while(cluster_index--) GetNextCluster(file);
+                // set the filepointer to the specified sector and byteposition
+                file->SectorOfCurrCluster = (u8) sector_index;
+                file->ByteOfCurrSector = (u16) byte_index;
+                // the fileposition now equals the filepointer
+                file->Position = (u32)fposition;
+                // the specified fileposition has been reached
+                retvalue = 0;
+        }
+        return(retvalue);
+}
 /****************************************************************************************************************************************************/
 /* Function:    fflush_(File *);                                                                                                                                                                                                                                        */
 /*                                                                                                                                                                                                                                                                                                      */
 /* Description: This function writes the data already in the buffer but not yet written to the file.                                                                                            */
 /*                                                                                                                                                                                                                                                                                                      */
+        }
         return(0);
-}
-/****************************************************************************************************************************************/
-/*      Function:               fclose_(File *file);                                                                                                                                                                                            */
-/*                                                                                                                                                                                                                                                                              */
-/*      Description:    This function closes the open file by writing the remaining data                                                                                                        */
-/*                                      from the buffer to the device and entering the filesize in the directory entry.                                                                         */
-/*                                                                                                                                                                                                                                                                              */
-/*      Returnvalue:    0 on success EOF on error                                                                                                                                                                                       */
-/****************************************************************************************************************************************/
-s16 fclose_(File_t *file)
-{
-        s16 returnvalue = EOF;
-        if(file == NULL) return(returnvalue);
-        returnvalue = fflush_(file);
-        UnlockFilePointer(file);
-        return(returnvalue);
+}
 /********************************************************************************************************************************************/
 /*      Function:               fgetc_(File *file);                                                                                                                                                                                                             */
 /*                                                                                                                                                                                                                                                                                      */
                 case 'w':
                 case 'a':
                         // If file position equals to file size, then the end of file has been reached.
                         // In this case it has to be checked that the ByteOfCurrSector is BYTES_PER_SECTOR
                         // and a new cluster should be appended.
                         // If the first sector of first cluster is unvalid, then the file claims no data clusters
                         // and size should be zero, therefore append a new Cluster too.
                         if(((file->Position >= file->Size) && (file->ByteOfCurrSector >= BYTES_PER_SECTOR)) || (file->FirstSectorOfFirstCluster == SECTOR_UNDEFINED))
+                        {
                                 if(CLUSTER_UNDEFINED == AppendCluster(file)) return(EOF);
+                        }
                         curr_sector  = file->FirstSectorOfCurrCluster;
                         curr_sector += file->SectorOfCurrCluster;
                         if(file->SectorInCache != curr_sector)
+                        {
                                 file->SectorInCache = curr_sector;
+                                {
                                         Fat16_Deinit();
                                         return(EOF);
+                                }
+                        }
                         file->Cache[file->ByteOfCurrSector] = (u8)c;            // write databyte into the buffer. The byte will be written to the device at once
                         if(file->Size == file->Position) file->Size++;          // a character has been written to the file so the size is incremented only when the character has been added at the end of the file.
                         file->Position++;                                                                       // the actual positon within the file.
                         file->ByteOfCurrSector++;                                                       // goto next byte in sector
                         if(file->ByteOfCurrSector >= BYTES_PER_SECTOR)          // if the end of this sector is reached yet
                         {       // save the sector to the sd-card
                                 if(SD_SUCCESS != SDC_PutSector(file->SectorInCache, file->Cache))
+                                {
                                         Fat16_Deinit();
                                         return(EOF);
+                                }
         while((object_cnt < count) && success)
+        {
                 object_size = size;
                 while((size > 0) && success)
+                {
-                        c = fputc_(*pbuff, file);                                                                               // write a byte from the buffer to the opened file.
+                        c = fputc_(*pbuff, file);                                                                                       // write a byte from the buffer to the opened file.
                         if(c != EOF)
+                        {
                                 pbuff++;
                                 size--;
+                        }
+                        }
+                }
                 if(success) object_cnt++;
+        }
-        return(object_cnt);                                                                                                                             // return the number of objects succesfully written to the file
+        return(object_cnt);             // return the number of objects succesfully written to the file
+}
         *pbuff = 0;     // set string terminator
         return(string);
+}
+/****************************************************************************************************************************************/
+/*      Function:               fclose_(File *file);                                                                                                                                                                                            */
+/*                                                                                                                                                                                                                                                                              */
+/*      Description:    This function closes the open file by writing the remaining data                                                                                                        */
+/*                                      from the buffer to the device and entering the filesize in the directory entry.                                                                         */
+/*                                                                                                                                                                                                                                                                              */
+/*      Returnvalue:    0 on success EOF on error                                                                                                                                                                                       */
+/****************************************************************************************************************************************/
+s16 fclose_(File_t *file)
+{
+        s16 returnvalue = EOF;
+        if(file == NULL) return(returnvalue);
+        returnvalue = fflush_(file);
+        UnlockFilePointer(file);
+        return(returnvalue);
+}
 /****************************************************************************************************************************************/
 /*      Function:               fexist_(const u8*);                                                                                                                                                                                                     */
 /*                                                                                                                                                                                                                                                                              */
 /*      Description:    This function checks if a file already exist.                                                                                                                                           */
 /*                                                                                                                                                                                                                                                                              */
+        {
                 return(1);
+        }
+}
+/********************************************************************************************************************************************/
+/*      Function:               fdelete_(s8* filepath);                                                                                                                                                                                                 */
+/*                                                                                                                                                                                                                                                                                      */
+/*      Description:    This function deletes the file with the specified filename from the filesystem                                                                                  */
+/*                                                                                                                                                                                                                                      */
+/*                                                                                                                                                                                                                                                                                      */
+/*      Returnvalue:    1 : specified file deleted succesfully 0: specified file not found                                                                                                              */
+/********************************************************************************************************************************************/
+u8 fdelete_(s8* const filepath)
+{
+        u8 retvalue = 0;
+        File_t file;
+        if(filepath == NULL) return(0);
+        // correct filepath formatting
+        Slashing_Path(filepath);
+        // if file is existent
+        if(FileExist(filepath, ATTR_NONE, ATTR_SUBDIRECTORY|ATTR_VOLUMELABEL, &file))
+        {
+                // and is not marked as readonly?
+                if((file.Attribute & ATTR_READONLY) != ATTR_READONLY)
+                {
+                        // try to delete the file content from the filesystem
+                        if(DeleteClusterChain(file.FirstSectorOfFirstCluster))
+                        {
+                                // and try delete the directory entry of the file
+                                retvalue = DeleteDirectoryEntry(&file);
+                        }
+                }
+        }
+        return(retvalue);
+}
 /****************************************************************************************************************************************************/
 /* Function:    s8* FAT16_GetVolumeLabel(void)                                                                                                                                                                                                                  */
 /*                                                                                                                                                                                                                                                                                                      */
 /* Description: This function returns the volume label                                                                                                                                                                                          */
         u16     dir_entry = 0;
         u8              i = 0;
         DirEntry_t * dir;
         File_t *file = NULL;
-        // if Partition is not valud return NULL
+        // if Partition is not valid return NULL
         if(!Partition.IsValid) return(pVolumeLabel);
         // if Volume label was read before return it
         if(Partition.VolumeLabel[0]!= '\0') return (Partition.VolumeLabel);
         // try to catch a file pointer
         file = LockFilePointer();
         if(file == NULL) return(pVolumeLabel);
         // search dir entries direct within the root directory area
         file->DirectorySector = 0;
         max_dir_sector = (Partition.MaxRootEntries * DIRENTRY_SIZE)/BYTES_PER_SECTOR;
         file->FirstSectorOfFirstCluster = Partition.FirstRootDirSector;
         // update current file data area position to start of first cluster
         file->FirstSectorOfCurrCluster  = file->FirstSectorOfFirstCluster;
         file->SectorOfCurrCluster               = 0;
         UnlockFilePointer(file);
         return(pVolumeLabel);
+}
-#define ATTR_NONE               0x00    // normal file
-#define ATTR_READONLY           0x01    // file is readonly
-#define ATTR_HIDDEN                     0x02    // file is hidden
-#define ATTR_SYSTEM                     0x04    // file is a system file
-#define ATTR_VOLUMELABEL        0x08    // entry is a volume label
-#define ATTR_LONG_FILENAME      0x0F    // this is a long filename entry
-#define ATTR_SUBDIRECTORY       0x10    // entry is a directory name
-#define ATTR_ARCHIVE            0x20    // file is new or modified
 /********************************************************************************************************************************************/
-/*      Function:               u8 FindItem(Find_t);                                                                                                                                                                                                                    */
+/*      Function:               u8 FindItem(Find_t);                                                                                                                                                                                                    */
 /*                                                                                                                                                                                                                                                                                      */
 /*      Description:    This function looks for the item specified by global structure FindElement in the actual directory                                      */
 /*                                                                                                                                                                                                                                                              */
 /*                                                                                                                                                                                                                                                                                      */
-/*      Returnvalue:    TRUE if an matching element was found                                                                                                                                                                           */
+/*      Returnvalue:    TRUE if an matching element was found                                                                                                                                                                   */
 /********************************************************************************************************************************************/
         u8              readpointer = 0;
         u8              writepointer = 0;
         u8              retvalue = 0;
         DirEntry_t      *DirectoryEntry;
         File_t  file;
+        SD_Result_t res=0;
         file.FirstSectorOfCurrCluster   = findelement->fp.FirstSectorOfCurrCluster;
         file.SectorOfCurrCluster        = findelement->fp.SectorOfCurrCluster;
+        {
                 max_dir_sector = Partition.SectorsPerCluster;                           // limit max secters before next cluster
+        }
         do
-        {                                                                                                                                                               // search the next 16 rootentries in this sector of the roordirectory.
+        {       // search the next 16 rootentries in this sector of the roordirectory.
+                res = SDC_GetSector(((u32) file.FirstSectorOfCurrCluster + (u32)file.SectorOfCurrCluster), file.Cache);                                         // Read the Rootdirectory.
-                if(SD_SUCCESS != SDC_GetSector(((u32) file.FirstSectorOfCurrCluster + (u32)file.SectorOfCurrCluster), file.Cache));                                             // Read the Rootdirectory.
+                if(res != SD_SUCCESS)
+                {
                         Fat16_Deinit();
                         return(0);
                 }
                 DirectoryEntry = (DirEntry_t *)file.Cache;
-                while((!retvalue)&&(index<16))
+                while((!retvalue)&&(index < 16))
                 {
-                        i=0;
+                        i = 0;
-                        if((u8) DirectoryEntry[index].Name[0] != 0xe5)                                                          // ignore deleted items.
+                        if( (u8)DirectoryEntry[index].Name[0] != SLOT_DELETED)          // ignore deleted items.
+                        {
-                                while((i<=10)&&((DirectoryEntry[index].Name[i] == findelement->searchstring[i]) || (findelement->searchstring[i]=='*') || findelement->searchstring[i]=='?'))
+                                while((i <= 10) && ( (DirectoryEntry[index].Name[i] == findelement->searchstring[i]) || (findelement->searchstring[i] == '*') || findelement->searchstring[i] == '?'))
+                                {
                                         i++;
                                 }
+                        }
+                        if((DirectoryEntry[index].Attribute & 0x30) && (DirectoryEntry[index].Attribute & findelement->attribmask) && (i == 11))
+                        {
-                        if((DirectoryEntry[index].Attribute <= 0x30) && (DirectoryEntry[index].Attribute & findelement->attribmask) && (i==11))
+                /* initialize the namestring with 0 */
                         for(i = 0; i < 12; i++) findelement->name[i] = 0;
-                for(readpointer=0;readpointer<=10;readpointer++)
+                for(readpointer = 0; readpointer <= 10; readpointer++)
+                                {
                                         if((DirectoryEntry[index].Name[readpointer] != ' ') && (readpointer!=8))
+                                        {
                                                 findelement->name[writepointer] = DirectoryEntry[index].Name[readpointer];      // copy the name of the item found to the find_structure.
                                                 writepointer++;
+                                        }
                                         else
+                                        {
                                                 if(DirectoryEntry[index].Attribute == ATTR_ARCHIVE)
+                                                {
-                                        if(readpointer < 8) readpointer=8;
+                                        if(readpointer < 8) readpointer = 8;
                                         if(DirectoryEntry[index].Name[readpointer] != ' ')
+                                        {
                                         findelement->name[writepointer] = '.';                                                  // then seperate the name and the extension by a '.' at index 8.
                                         writepointer++;
                                         findelement->name[writepointer] = DirectoryEntry[index].Name[readpointer];      // copy the name of the item found to the find_structure.
                                         writepointer++;
+                                        }
                                             else break;
+                                                }
-                            else break;
-                        }
-                        /* terminate the namestring with 0 for debugpurposes*/
+                            else break;
-                        findelement->name[12] = 0;
+                        }
                                 }
                                 findelement->fp.FirstSectorOfFirstCluster = (u32) DirectoryEntry[index].StartCluster;
                                 findelement->fp.DirectoryIndex   = index;
                                 findelement->fp.FirstSectorOfCurrCluster   = file.FirstSectorOfCurrCluster;
                                 findelement->fp.DirectorySector  = (file.FirstSectorOfCurrCluster + file.SectorOfCurrCluster);
                                 findelement->fp.SectorOfCurrCluster      = file.SectorOfCurrCluster;
                 findelement->fp.Size            = DirectoryEntry[index].Size;
                                 findelement->fp.Attribute               = DirectoryEntry[index].Attribute;
                 retvalue = 1;
+                        }
                         /* search the next sector */
                         index++;
+                }
                 /* this sector has been searched but we havn't found what we are looking for. Therefore we have to find the next sector */
                 if(!retvalue)                                                                                                                           // file not found in this sector so take next sector.
+                {
                         /* in the next sector we start looking for the specified entry beginning at index 0 */
                         index = 0;
                         /* there are still sectors to be read within the cluster or within the linear addresspace of the rootdirectory */
-                        if(file.SectorOfCurrCluster < max_dir_sector-1)  file.SectorOfCurrCluster++; else end_of_directory_not_reached = 0;
+                        if(file.SectorOfCurrCluster < max_dir_sector-1)  file.SectorOfCurrCluster++;
+                        /* if we are looking for an directoryentry outside the rootdirectory and have reached the end of the cluster we have to get the next one */
+                        else if(Partition.FirstDataSector <= file.FirstSectorOfCurrCluster)
+                        {
+                                end_of_directory_not_reached = GetNextCluster(&file);
+                        }
-                        /* if we are looking for an directoryentry outside the rootdirectory and have reached the end of the cluster we have to get the next one */
+                        // within the rootdirectory we abort searching for elements after the maximun number of possible rootentries has beensearched
-                        if(Partition.FirstDataSector <= file.FirstSectorOfCurrCluster)
+                        else
+                        {
-                                end_of_directory_not_reached = GetNextCluster(&file);
+                                end_of_directory_not_reached = 0;
+                        }
+                }
         }
         while((end_of_directory_not_reached) && (!retvalue) );
         u8 index = 0;
         findelement->fp.DirectoryIndex++;
         /* before we start searching an element we clear the complete namestring within the structure FindElement */
-        for(index=0;index<11;index++) findelement->name[index] = 0;
+        for(index = 0; index < 11; index++) findelement->name[index] = 0;
         if(FindItem(findelement))
+        {
                 itemfound = 1;
 /*      Returnvalue:    (1) if Element was found. (0) if no valid element was found                                                                                                                     */
 /********************************************************************************************************************************************/
 u8 findfirst_(const s8* name, u8 attribmask, Find_t *findelement)
+{
         u8 itemfound = 0;
         u8 index = 0;
         /* initialize the FindElement structure */
-        findelement->fp.FirstSectorOfFirstCluster = 0;  // First sector of the first cluster of the file.
+        findelement->fp.FirstSectorOfFirstCluster = 0;                                  // First sector of the first cluster of the file.
-        findelement->fp.FirstSectorOfCurrCluster = Partition.CurrentWorkingDirectory;                                   // First sector of the cluster which is edited at the moment.
+        findelement->fp.FirstSectorOfCurrCluster = Partition.CurrentWorkingDirectory;   // First sector of the cluster which is edited at the moment.
-        findelement->fp.SectorOfCurrCluster = 0;                                                        // The sector within the current cluster.
+        findelement->fp.SectorOfCurrCluster = 0;                                                // The sector within the current cluster.
         findelement->fp.ByteOfCurrSector = 0;                                                   // The byte location within the current sector.
         findelement->fp.Size = 0;                                                                               // The size of the opend file in bytes.
         findelement->fp.Position = 0;                                                                   // Pointer to a character within the file 0 < fileposition < filesize
-        findelement->fp.DirectorySector = 0;                                                            // the sectorposition where the directoryentry has been made.
+        findelement->fp.DirectorySector = 0;                                                    // the sectorposition where the directoryentry has been made.
         findelement->fp.DirectoryIndex = 0;                                                             // The index to the directoryentry within the specified sector.
         findelement->attribfilter = 0;
         findelement->attribmask = attribmask;
-        findelement->searchstring[0]=0;
+        findelement->searchstring[0] = 0;                                                               // terminate string at the begin (=NULL)
+        // bring it to the 8.3 format
-        /* seperate the name of the element to be found from the filepath and bring it to the 8.3*/
+        if(NULL == SeperateFormatedDirName(name, findelement->searchstring)) return(0);
-        SeperateDirName(name, findelement->searchstring);
-        /* after the name of the element is in 8.3 we process the wildcards (*). After an * all following character are wildcards to */
+        //process the wildcards (*). After an * all following character are wildcards to
-        for(index=0;index<8;index++)
+        for(index = 0;index < 8;index++)
+        {
                 /* if we find an wildcard within the name of the searchstring all remaining character after the wildcard shall be wildcards also */
                 if(findelement->searchstring[index] == '*')
                 {
                         /*  */
-                        while(++index <8) findelement->searchstring[index] = '*';
+                        while(++index < 8) findelement->searchstring[index] = '*';
                 }
         }
-        for(index=8;index<11;index++)
+        for(index = 8;index < 11;index++)
+        {
                 /* if we find an wildcard within the name of the searchstring all remaining character after the wildcard shall be wildcards also */
                 if(findelement->searchstring[index] == '*')
                 {
                         /*  */
-                        while(++index <11) findelement->searchstring[index] = '*';
+                        while(++index < 11) findelement->searchstring[index] = '*';
                 }
+        }
         /* the value of ...DirectoryIndex will be incremented in findnext_() thererfore it has to be decremented in findfirst_() */
         findelement->fp.DirectoryIndex--;
         /* now lets search for the item within the direcory */
         itemfound = findnext_(findelement);
-        return(itemfound);
-}
-/********************************************************************************************************************************************/
-/*      Function:               u8 GetDirCount(s8* filepath);                                                                                                                                                                                   */
-/*                                                                                                                                                                                                                                                                                      */
-/*      Description:    This function counts the number of subdirectories the dirpath contains                                                                                                  */
-/*                                                                                                                                                                                                                                                              */
-/*                                                                                                                                                                                                                                                                                      */
-/*      Returnvalue:    then number of subdirectories within the specified path                                                                                                                                 */
-/********************************************************************************************************************************************/
-u8 GetDirCount(u8 *dirpath)
-{
-   u8 i=0;
-   u8 cnt=0;
-   while(dirpath[i] != 0 )
-   {
-      if(dirpath[i]=='/')
-      {
-         if(dirpath[i+1]!=0) cnt++;                                            // ignore last'/'
-      }
-      i++;
-   }
-   i=0;
    return(cnt);
-}
+        return(itemfound);
+}
 /********************************************************************************************************************************************/
-/* Funtion:     char *GetSubDirectory (char *dirpath, char *directory)                                                                                                                                          */
+/* Function:    s8 *GetSubDirectory (s8 *dirpath, s8 *directory)                                                                                                                                                        */
 /*                                                                                                                                                                                                                                                                                      */
-/* Description: this function returns a pointer to the beginning of the next subdirectory or NULL                                                                                       */
+/* Description: this function parses the dirpath string and copies the first directroy name to the location pointed to by directroy                     */
 /*                                                                                                                                                                                                                                                                                      */
 /*                                                                                                                                                                                                                                                                                      */
-/* returnvalue:   number of subdirectories in the filepath                                                                                                                                                                      */
+/* returnvalue:  a pointer to the beginning of the next subdirectory or NULL                                                                                                                            */
 /********************************************************************************************************************************************/
-u8 * GetSubDirectory(u8 *dirpath, u8 *directory)
+s8 * GetSubDirectory(s8 *dirpath, s8 *directory)
 {
-   u8 *cptr = dirpath;
+   s8 *cptr = dirpath;
-   u8 *dptr = directory;
+   s8 *dptr = directory;
-   u8 *retvalue = NULL;
+   s8 *remainingpath = NULL;
    /* if the first character of the path is an '/' we go to the next character */
    if(*cptr == '/') cptr++;
    /* search end of path or subdirectory*/
    while((*cptr != 0) && (*cptr != '/'))
    {
-      *dptr = *cptr;
+      *dptr = *cptr;   // copy to directory string buffer
        dptr++;
        cptr++;
+   }
+   if(*cptr!=0) remainingpath = ++cptr; // return pointer to remaining path string
-   if(*cptr!=0) retvalue = ++cptr;
+   *dptr = 0; // terminate directory name string
-   *dptr = 0;
    return(remainingpath);
-   return(retvalue);
+}
-}
 /********************************************************************************************************************************************/
-/*      Function:               s8 *GetPath(void);                                                                                                                                                                                                              */
+/*      Function:               u8 chdir_(s8* const path);                                                                                                                                                                                              */
 /*                                                                                                                                                                                                                                                                                      */
-/*      Description:    This function function returns a pointer to the absolute path of the active partition                                                                   */
+/*      Description:    This function changes the current working directory to the directory specified by the filepath                                                  */
+/*                  by function findfirst()                                                                                                                                                                                                     */
-/*                                                                                                                                                                                                                                      */
+/*                                                                                                                                                                                                                                                                                      */
-/*                                                                                                                                                                                                                                                                                      */
+/*      Returnvalue:                                                                                                                                                                                                                                                    */
+/********************************************************************************************************************************************/
+u8 chdir_(s8* const path)
+{
-/*      Returnvalue:                                                                                                                                                                                                                                                    */
-/********************************************************************************************************************************************/
+        u8              retvalue = 0;                                   // the value returned by this function
+        u32     ultemp = 0;                                             // temp. variable
-s8 *GetPath(void)
-{
-        return(Partition.PathToCwd);
+        s8      *dirpath = path;                                // pointer to the remaining path string
-}
-/********************************************************************************************************************************************/
-/*      Function:               void SetPathToRoot(void);                                                                                                                                                                                                       */
-/*                                                                                                                                                                                                                                                                                      */
+        s8      dirname[64];                                    // a buffer containing the name of the subdirectory we are actually looking for
-/*      Description:    This function sets the path to the rootdirectory                                                                                                                                                */
+        Find_t  fe;                                                             // The findelement needed for function findfirst to find the subdirectory entry
-/*                                                                                                                                                                                                                                      */
+        s8              tp[256];                                                // temporarily we remember the actual path until the operation has finished successfully
+        u32     tcwd = 0;                                               // temporarily we remember the actual current working directory
+        if(path == NULL) return(0);                             // return immediately of no path is given
+        // correct filepath formatting
+        Slashing_Path(path);
+        // lets remember the actual path and correspondig directory sector
+        strcpy(tp, Partition.PathToCwd);
-/*                                                                                                                                                                                                                                                                                      */
+        tcwd = Partition.CurrentWorkingDirectory;
-/*      Returnvalue:                                                                                                                                                                                                                                                    */
+        if(path[0] == '/') // if the path is absolute we begin at the rootdirectory
+        {
-/********************************************************************************************************************************************/
+                strcpy(Partition.PathToCwd, "/");
+                Partition.CurrentWorkingDirectory = Partition.FirstRootDirSector;
+        }
+        // parse through all the subdirectories within the path
+        do
+        {
+                dirpath = GetSubDirectory(dirpath, dirname); // get the name of the subdirectory we are looking for and the remainig path
-void SetPathToRoot(void)
+                if(dirname[0] == 0)             // if no directory name is available
-{
+                {
+                        retvalue = 1;                   // we are done
+                        break;                                  // break the loop
+                }
+                // search for the next subdirectory within the path
-        /* lets point to the rootdirectory */
+                if(findfirst_(dirname, ATTR_SUBDIRECTORY, &fe))
+                {
+                        // we try to change into the directory "..". Now we have to delete the last direntry from the path
+                        if(strcmp(dirname, "..") == 0) CWDPath_Pop();
+                        // we try to change into the actual directory so there's nothing todo
+                        else if(dirname[0] == '.') return(1);
+                        // otherwise we append the name of the directory we are changing in to the path
-        strcpy(Partition.PathToCwd, "/");
+                        else CWDPath_Push(dirname);
+                        // The startcluster within an directory entry specifies the position within the fat where the file or directory starts
+                        ultemp = (u32) fe.fp.FirstSectorOfFirstCluster;
+                        // do we have to change into the rootdirectory?
+                        if(ultemp)
+                        {
+                                // the first 2 entries are reserved for '.' and '..'
+                                ultemp -= 2;
+                                // now we have to transform the position within the fat into the corrosponding sectoraddress relative to the beginning of the datasection of the active partition
+                                ultemp *= Partition.SectorsPerCluster;
+                                // at least we make the sectoraddress absolute by adding the relative address to the beginning of the datasection of the active partition
+                                ultemp += Partition.FirstDataSector;
+                                // the cwd now points to the specified directory
+                                Partition.CurrentWorkingDirectory = ultemp;
+                        }
+                        else // (=0) root directory
+                        {
+                                // the cwd now points to the rootdirectory
+                                Partition.CurrentWorkingDirectory = Partition.FirstRootDirSector;
-}
+                        }
+                        retvalue = 1;
+                }
-/********************************************************************************************************************************************/
+                else // subdirectory not found
-/*      Function:               void AppendDirToPath(s8* directory);                                                                                                                                                                                    */
+                {
-/*                                                                                                                                                                                                                                                                                      */
+                        retvalue = 0;           // no success tracing along the given directory chain
-/*      Description:    This function function appends the name of an directory to the Path to the CWD                                                                                  */
+                        break;                          // break the loop
 /*                                                                                                                                                                                                                                      */
+        }
-/*                                                                                                                                                                                                                                                                                      */
+        while(dirpath != NULL);  // do this until all subdirectories have been found
-/*      Returnvalue:                                                                                                                                                                                                                                                    */
-/********************************************************************************************************************************************/
+        // if we could not change to the specified directory we restore the actual path
+        if(!retvalue)
-void AppendDirToPath(s8* directory)
+        {
                 Partition.CurrentWorkingDirectory = tcwd;
-        /* append the name of the directory to the path */
+                strcpy(Partition.PathToCwd, tp);
         strcat(Partition.PathToCwd, directory);
-        /* append a '/' after the directoryname */
+        return(retvalue);
         strcat(Partition.PathToCwd, "/");
+/********************************************************************************************************************************************/
+/*      Function:               u8 rmdir_(s8* dname);                                                                                                                                                                                                           */
+/*                                                                                                                                                                                                                                                                                      */
+/*      Description:    This function deletes the directory with the specified filename from the filesystem                                                                             */
+/*                                                                                                                                                                                                                                      */
+/*                                                                                                                                                                                                                                                                                      */
+/*      Returnvalue:    1 : specified directory deleted succesfully 0: specified directory not found                                                                                    */
+/********************************************************************************************************************************************/
-}
+u8 rmdir_(s8* const dirpath)
+{
+        u8 retvalue = 0;
+        Find_t fe;
+        u32 cwd;
+        s8 path[256];
+        s8 *dn;
+        s8 *dp;
-/********************************************************************************************************************************************/
+        if(dirpath == NULL) return(0);
-/*      Function:               RemoveLastDirFromPath(void);                                                                                                                                                                                    */
+        // correct filepath formatting
-/*                                                                                                                                                                                                                                                                                      */
+        Slashing_Path(dirpath);
-/*      Description:    This function removes the last directory from the path to the cwd                                                                                                               */
-/*                                                                                                                                                                                                                                      */
+    // remember the current workingdirectory
-/*                                                                                                                                                                                                                                                                                      */
+        cwd = Partition.CurrentWorkingDirectory;
-/*      Returnvalue:                                                                                                                                                                                                                                                    */
-/********************************************************************************************************************************************/
+        // create local copy of the path
+        strcpy(path, dirpath);
-void RemoveLastDirFromPath(void)
+        // seperate the filepath from the last directory within the path that shall be deleted
-{
+        // start searching for the name of the directory to be deleted from the beginning of the path
+        dn = path;
+        dp = path;
-        /* a pointer to the beginning of the absolute path to the cwd */
+        // search the complete path until the end of the string is found
-        s8 * cptr = Partition.PathToCwd;
+        while(*dn != 0) dn++;
-        /* lets find the end of the path to the cwd */
+        // now check if the last directory whithin the path is terminated with an '/' and remove the '/' from the directoryname
-        while(*cptr != 0 ) cptr++;
+        if(*(dn-1) == '/') *--dn = 0;
+        // now find the beginning of the last directoryentry
+        while((*dn != '/') && (dn > path)) dn--;
+        // beginning of the last directory found
+        if(*dn == '/')
+        {
+                // remove the directoryname from the path by terminating the path with 0
-        /* if the path is terminated with an '/' */
+                *dn = 0;
+                // the dirname begins 1 character after the terminated path
+                dn++;
+        }
+        // we couldn't find a path before the directory to be deleted or no directoryname at all
+        else
+        {
+                // there is no path before the name of the directory to be deleted
+                if(dn == path)
+                {
+                        // if there is a name of a directory to be deleted?
+                        if(*dn == 0) return(0);
+                        // the directory to be deleted is within the actual directory therefore we don't have to change the directory before deleting the directory
+                        dp = NULL;
+                }
+        }
+        // switch to the directory containing the directory to be deleted if neccessary
+        if(dp != NULL)
+        {
+                if(!chdir_(dp)) return(0);
+        }
+        // now we have to find the specified directory to be deleted
+        retvalue = findfirst_(dn, 0xff, &fe);
+        // was the specified directory found?
+        if(retvalue)
+        {
+                // before we delete the directory we check if the directory is empty
+                if(chdir_(dn))
+                {
+                        if(findfirst_("*.*", 0xff, &fe))
+                        {
+                                // within an directory that shall be deleted only the entries . and .. are allowed
+                                if((strncmp(fe.name, ".", 1) != 0) && (strncmp(fe.name, "..", 2) != 0)) retvalue = 0;
+                                while(findnext_(&fe))
+                                {
-        if((*(cptr-1)) == '/') *(cptr-1)=0;
+                                        if((strncmp(fe.name, ".", 1) != 0) && (strncmp(fe.name, "..", 2) != 0)) retvalue = 0;
+                                }
+                        }
+                        chdir_("..");
+                }
+                // directory couldn't be entered, is a real file?
+                else
+                {
+                        retvalue = 0;
+                }
+                // specified directory is empty
+                if(retvalue)
         /* now lets find the beginning of the last directorientry */
+                        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))
+                        {
+                                // try to clear the allocated clusters within the fat
-        while((*cptr != '/' ) && cptr > Partition.PathToCwd) cptr--;
+                                if(DeleteClusterChain(fe.fp.FirstSectorOfFirstCluster))
+                                {
-        /* is there one subdirectory left within the path? */
+                                        // delete the directoryentry within the specified directory
-        if(cptr > Partition.PathToCwd)
+                                        if(DeleteDirectoryEntry(&(fe.fp))) retvalue = 1;
+                                }
-                /* we delete the direntry by terminating the path with 0 */
+                        }
-                *cptr = 0;
+                }
+        }
-        /* there is no subdirectory left within the path. Therefore we create the root instead. */
-        else
+        // restore the actual path
-        {
-                *cptr = '/';
-                *(cptr+1) = 0;
-        }
-}
-/********************************************************************************************************************************************/
-/*      Function:               chdir_(s8* filepath);                                                                                                                                                                                                   */
-/*                                                                                                                                                                                                                                                                                      */
-/*      Description:    This function changed the current working directory to the directory specified by the filepath                                                  */
-/*                  by function findfirst()                                                                                                                                                                                                     */
+        Partition.CurrentWorkingDirectory = cwd;
 /*                                                                                                                                                                                                                                                                                      */
-/*      Returnvalue:                                                                                                                                                                                                                                                    */
-/********************************************************************************************************************************************/
-/*
-#define ATTR_NONE               0x00    // normal file
-#define ATTR_READONLY           0x01    // file is readonly
-#define ATTR_HIDDEN                     0x02    // file is hidden
-#define ATTR_SYSTEM                     0x04    // file is a system file
-#define ATTR_VOLUMELABEL        0x08    // entry is a volume label
+        return(retvalue);
-#define ATTR_LONG_FILENAME      0x0F    // this is a long filename entry
+}
-#define ATTR_SUBDIRECTORY       0x10    // entry is a directory name
-#define ATTR_ARCHIVE            0x20    // file is new or modified
-*/
-u8 chdir_(s8 *path)
-{
-        u8              retvalue = 0;                                   // the value returned by this function
-        u32     ultemp = 0;                                             // temp. variable
-        u8     *directory = path;                               // pointer to a directoryname within the path
-        u8      dircount = 0;                                   // the number of subdirectoryentries within the path
-        u8      cache[64];                                              // a buffer containing the name of the subdirectory we are actually looking for
-        Find_t  fe;                                                             // The findelement needed for function findfirst to find the subdirectoryentry
-        s8              tp[256];                                                // temporarily we remember the actual path until the operation has finished successfully
+/********************************************************************************************************************************************/
-        u32     cwdt = 0;
-        s8     *cptr;
-        /* bring the path into the correct syntax */
-        cptr = path;
-        /* search the whole string */
-        while(*cptr != 0 )
-        {
-                if(*cptr == '\\') *cptr = '/';
-                cptr++;
-        }
-        /* lets remember the actual path */
-        strcpy(tp, Partition.PathToCwd);
+/*      Function:               mkdir_(s8* dirpath);                                                                                                                                                                                                    */
-        cwdt = Partition.CurrentWorkingDirectory;
-        /* how many subdirectories are there within the path? */
-        dircount = GetDirCount(path);
-        /* if the path is absolute we begin at the rootdirectory */
+/*                                                                                                                                                                                                                                                                                      */
-        if(path[0] == '/')
-        {
-                strcpy(Partition.PathToCwd, "/");
-                Partition.CurrentWorkingDirectory = Partition.FirstRootDirSector;
-                /* if there is no other pathinformation we only switch to the rootdirectory. So theres nothing left todo.*/
-                if(!dircount) return(1);
-        }
-        /* now we parse through all the subdirectories within the path */
-        do
-        {
-                /* until all the subdirectories within the path have been processed */
-        if(dircount) dircount--;
-                /* this is the name of the next subdirectory we are looking for */
-            directory = GetSubDirectory(directory, cache);
-                /* search for the next subdirectory within the path */
-                if(findfirst_(cache, ATTR_SUBDIRECTORY, &fe))
-                {
-                        /* we try to change into the directory "..". Now we have to delete the last direntry from the path */
-                        if(strcmp(cache,"..") == 0) RemoveLastDirFromPath();
-                        /* we try to change into the actual directory so there's nothing todo */
-                        else if(cache[0] == '.') return(1);
-                        /* otherwise we append the name of the directory we are changing in to the path */
-                        else AppendDirToPath(cache);
-                        /* The startcluster within an directoryentry specifies the position within the fat where the file or directory starts */
-                        ultemp = (u32) fe.fp.FirstSectorOfFirstCluster;
-                        /* the first 2 entries are reserved for '.' and '..' */
-                        ultemp -= 2;
+/*      Description:    This function creates the directory with the specified pathname in the filesystem                                                                               */
-                        /* now we have to transform the position within the fat into the corrosponding sectoraddress relative to the beginning of the datasection of the active partition*/
+/*                                                                                                                                                                                                                                      */
-                        ultemp *= Partition.SectorsPerCluster;
-                        /* at least we make the sectoraddress absolute by adding the relative address to the beginning of the datasection of the active partition */
+/*                                                                                                                                                                                                                                                                                      */
-                        ultemp += Partition.FirstDataSector;
+/*      Returnvalue:    1 : specified directory created succesfully 0: specified dir exist already                                                                                              */
-                        /* the cwd now points to the specified directory */
+/********************************************************************************************************************************************/
+u8 mkdir_(s8* const dirpath)
+{
+        u8 retvalue = 0;
+        File_t file;
+        if(dirpath == NULL) return(0);

Subversion Repositories NaviCtrl

(root)/tags/V0.30g/fat16.c @ 650 - Rev 407 → 427