예제 #1
0
bool FS_RecDeleteDir(const char* path)
{
    FS_Dir      dir;
    FS_DirEntry entry;
    bool        ret;
    const char* dirname;
    size_t      pathlen;
    size_t      tmplen;
    char*       tmp;

    if (!FS_IsDirectory(path))
        return false;

    if (FS_IsSpecial(path))
        return false;

    dir = FS_OpenDir(path);
    if (dir == FS_INVALID_DIR)
        return false;

    pathlen = strlen(path);
    while ((entry = FS_ReadDir(dir)) != FS_INVALID_DIR_ENTRY)
    {
        dirname = FS_DirEntryName(entry);
        if (FS_IsSpecial(dirname))
            continue;

        // create relative path in temporary buffer
        tmplen = pathlen + 1 + strlen(dirname) + 1;
        tmp = new char[tmplen];
        memcpy(tmp, path, pathlen);
        tmp[pathlen] = FS_Separator();
        memcpy(tmp + pathlen + 1, dirname, strlen(dirname));
        tmp[tmplen - 1] = '\0';

        if (FS_IsDirectory(tmp))
            ret = FS_RecDeleteDir(tmp);
        else
            ret = FS_Delete(tmp);

        delete[] tmp;
        if (!ret)
            return false;
    }

    FS_CloseDir(dir);
    return FS_DeleteDir(path);
}
예제 #2
0
//*************************************************************************************
//  Function:		CETYPE FS_chDir (FSFILE* chDir)
//-------------------------------------------------------------------------------------
//  Summary:		Changes Current Working Directory (CWD) to the directory pointed to
//					by chDir
//  Input:			
//					chDir	- pointer to the File Object structure that on SUCCESS
//							  will become the new CWD.
//  Return Values:
//					CETYPE enum member (expected CE_GOOD)
//					Other codes depending on encountered error conditions
//*************************************************************************************
CETYPE 		FS_chDir (FSFILE* chDir)
	{
 	//----------------------------------------------------------------
	// Validate conditions and parameters
 	//----------------------------------------------------------------
 	if (!SDFS_InitStatus)
 		return CE_NOT_INIT;		// FS is not initialized!
 	if (NULL == chDir)
 		return CE_INVALID_ARGUMENT;
 	if (!FS_IsDirectory(chDir))	
 		return CE_NOT_A_DIRECTORY;
 	//----------------------------------------------------------------
 	SDFS_CopyFSFILE(&SDFS_CWD, chDir);
 	//----------------------------------------------------------------
	return CE_GOOD;
	}
예제 #3
0
//*********************************************************************************
//  Function:		CETYPE	FS_Recover(FSFILE* filePtr)
//---------------------------------------------------------------------------------
//  Summary:		Recovers the length of a 0-length file identified by the filePtr
//					based upon the number of allocated clusters
//  Input:
//    				filePtr -  	Pointer to the File Object structure identifying the
//								file to be recovered
//  Return Values:
//    				CE_GOOD	-	File was recovered successfully
//								Other return codes may identify various error 
//								conditions as required.
//*********************************************************************************
CETYPE	FS_Recover(FSFILE* filePtr)
	{
 	//----------------------------------------------------------------
	// Validate conditions and parameters
 	//----------------------------------------------------------------
 	if (!SDFS_InitStatus)
 		return CE_NOT_INIT;		// FS is not initialized!
 	if (NULL == filePtr)
 		return CE_INVALID_ARGUMENT;		
 	//----------------------------------------------------------------
    // Check if this is a file and not a Directory
    if( FS_IsDirectory(filePtr) )
        return CE_DIRECTORY;
    // Check if the file is actually 0-length
    if( FS_GetSize(filePtr) > 0 )
        return CE_GOOD;
	//-----------------------------------------------------------------
	DWORD	ClsSize	= (DWORD)SDFS_VolumeInfo.SecPerClus 
						   * SDFS_VolumeInfo.sectorSize;
	DWORD	ClsNum	= SDFS_DirGetFirstCluster(&filePtr->dirFileEntry);
	//-----------------------------------------------------------------
	while (ClsNum < EOC_CLUSTER_FAT32)
		{
	    //-------------------------------------------------------
		// Process cluster chain
	    //-------------------------------------------------------
	    // The first 2 clusters in FAT32 are reserved...
	    if	( ClsNum < 2)  // Cluster Number can't be "0" and "1"
	    	return CE_RECOVERY_FAIL;
	    //-------------------------------------------------------
	    filePtr->dirFileEntry.DIR_FileSize += ClsSize;
	    //-------------------------------------------------------
	    // Load next cluster in the chain
	    //-------------------------------------------------------
	    ClsNum = SDFS_FATCacheRead(ClsNum);
		}
	//----------------------------------------------------------------- 
	// Flush updates to disk
	//----------------------------------------------------------------- 
	return FS_Flush(filePtr);
	}
예제 #4
0
//*********************************************************************************
//  Function:		CETYPE	FS_Delete (FSFILE* filePtr)
//---------------------------------------------------------------------------------
//  Summary:		Deletes the file identified by the filePtr
//  Input:
//    				filePtr -  	Pointer to the File Object structure identifying the
//								file to be deleted
//  Return Values:
//    				CE_GOOD	-	File was deleted successfully
//								Other return codes may identify various error 
//								conditions as required.
//*********************************************************************************
CETYPE	FS_Delete (FSFILE* filePtr)
	{
 	//----------------------------------------------------------------
	// Validate conditions and parameters
 	//----------------------------------------------------------------
 	if (!SDFS_InitStatus)
 		return CE_NOT_INIT;		// FS is not initialized!
 	if (NULL == filePtr)
 		return CE_INVALID_ARGUMENT;		
 	//----------------------------------------------------------------
    // Check if this is a file and not a Directory
    if( FS_IsDirectory(filePtr) )
        return CE_DELETE_DIR;
    // Check if the file attributes allow write
    if( FS_IsReadOnly(filePtr) )
        return CE_READONLY;
	//-----------------------------------------------------------------
	CETYPE 	RC		= CE_GOOD;
	DWORD	ClsNum	= SDFS_DirGetFirstCluster(&filePtr->dirFileEntry);
	//----------------------------------------------------------------- 
	// Free Cluster Chain and flush changes to disk
	//----------------------------------------------------------------- 
	if (CE_GOOD != (RC = SDFS_FATEraseClusterChain(ClsNum)))
		return RC;
	ClsNum = SDFS_FATCacheFlush();
	if (CLUSTER_FAIL_FAT32 == ClsNum)
		return CE_DISK_ERROR;
	//----------------------------------------------------------------- 
	// Mark Directory Entry as "deleted" and flush updates to disk
	//----------------------------------------------------------------- 
	filePtr->dirFileEntry.DIR_Name[0] = DIR_DEL;
	if (CE_GOOD != (RC = FS_Flush(filePtr)))
		return RC;
	//----------------------------------------------------------------- 
	 return  SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE);
	}
예제 #5
0
파일: fs_debug.c 프로젝트: bk1472/d2a_prj
void debug_filesystem(void)
{
	FS_HANDLE FileHandle=0;
	UINT32    command;
	FILE_INFO fileinfo={0};
	UINT08    ShortFileName[13]={0};
	UINT08    FileBuffer[512];
	int       FileNo;
	int       iter;

	do
	{
		ShowMenu();
		command = ReadKeyInput("Select Command");

		switch(command)
		{
			case 0x01:
				{
				int ret;
				ret = FS_OpenDriver();

				if(ret == 1)
					dbgprint("Open Driver Success!\n");
				else
					dbgprint("Open Driver Error!\n");
				}
				break;

			case 0x02:
				rprint0n("No Use\n");
				break;

			case 0x03:
				//Mount
				if(!FS_Mount())
				{
					rprint0n("Mount Fail!\n");
					break;
				}
				//Open Root Dir
				fileinfo.Target[0] = '*';
				fileinfo.Target[1] = '.';
				fileinfo.Target[2] = '*';

				if(!FS_OpenRootDir(&fileinfo))
				{
					rprint0n("Open Root Directory Fail!\n");
					break;
				}
				//Find Start
				FS_FindStart(&fileinfo);

				//Show File Name
				for(iter=0; iter<fileinfo.TotalCount; iter++)
				{
					rprint0n("File%02d : ", iter);
					if(FS_GetFile(iter, &fileinfo))
					{
						if(FS_GetFileName(&fileinfo, ShortFileName) )
						{
							rprint0n("%s : ", ShortFileName);
							if(FS_IsDirectory(&fileinfo))
							{
								rprint0n("Directory", ShortFileName);
							}
							else
							{
								rprint0n("File", ShortFileName);
							}
							#if 0
							{
							UINT08 index;
							UINT08 LongFileName[512]={0};
							index = FS_GetLongFileName(&fileinfo, LongFileName);
							ViewLongName(LongFileName, index);
							}
							#endif
						}
					}
					rprint0n("\n");
				}
				break;
			case 0x04:
				FileNo = (int)ReadDecimalKeyInput("File Number");
				if(FileNo >= fileinfo.TotalCount)
				{
					rprint0n("Invalid File Number !\n");	break;
				}

				//Get File
				if(FS_GetFile(FileNo, &fileinfo))
				{
					if(FS_IsDirectory(&fileinfo))
					{
						//rprint0n("File Open Fail - Directory\n");
						if(FS_OpenDir(&fileinfo))
						{
							FS_FindStart(&fileinfo);

							//Show File Name
							for(iter=0; iter<fileinfo.TotalCount; iter++)
							{
								rprint0n("File%02d : ", iter);
								if(FS_GetFile(iter, &fileinfo))
								{
									if(FS_GetFileName(&fileinfo, ShortFileName) )
									{
										rprint0n("%s : ", ShortFileName);

										if(FS_IsDirectory(&fileinfo))
										{
											rprint0n("Directory", ShortFileName);
										}
										else
										{
											rprint0n("File", ShortFileName);
										}
									}
								}
								rprint0n("\n");
							}
						}
						break;
					}
					//Open File
					FileHandle = FS_OpenFile(&fileinfo);
					if(FileHandle == 0xFFFFFFFF)
					{
						rprint0n("Invalid File Handle!\n");	break;
					}
				}
				rprint0n("File Open - Index %d\n", FileNo);
				break;
			case 0x05:
				if(FileHandle == 0)          break;
				if(FileHandle == 0xFFFFFFFF) break;
				if(FileHandle == 0xCCCCCCCC) break;

				//Read File
				if(FS_ReadFile(FileHandle, FileBuffer, 1))
				{
					dbgprint("^B^=============    File Read   ===============\n");
					hexdump("Read File", FileBuffer, 512);
					dbgprint("^B^============================================\n");
					break;
				}
				rprint0n("File Read Fail! or End of File\n");
				break;

			case 0x06:
				rprint0n("File Close\n");
				FS_CloseFile(FileHandle);
				//Close File
				break;
			case 0x07:
				//UnMount
				break;
			case 0xFF:
				command = INVALID_COMMAND;
			}
	}while(command != INVALID_COMMAND);
}
예제 #6
0
//*************************************************************************************
//  Function:		CETYPE FS_CreateFile (	const char * 	FileName, 
//											FILE_MODE 		mode,
//											FSFILE* 		filePtr )
//  Summary:		Creates/Opens a file with ascii name provided in FileName
//  Input:
//					FileName 	- The name of the file to open
//  		  		mode 		- File open mode (FILE_MODE enum)
//        			- FS_CREATE_NEW		- Create a new file or replace an existing file.
//        			- FS_OPEN_EXISTING	- Open existing file for read/write access or 
//										  creates a new file; file is positioned at the
//										  beginning.
//         			- FS_APPEND			- Open existing file for read/write access or 
//										  creates a new file; file is positioned just
//										  past the last byte.
//        			- FS_READ_ONLY		- Open existing file in read-only mode; file
//										  positioned at the beginning.
//					filePtr		- pointer to FSFILE data structure that will be confi-
//								  gured ro provide access to the file if function
//								  succeeds.
//  Return Values:
//    				CETYPE - Expected CE_GOOD, but may have other codes depending on
//							 various error conditions.
//  Description:
//    				This function will create and/or open specified file.
//    				The specified file name will be formatted to ensure that it's in 8.3
//					format. Next, the search for the specified file name will be
//					performed. If the name is found, the action will be taken based
//					upon the requested File Mode.  
//*************************************************************************************
CETYPE FS_CreateFile (	const char* FileName, FILE_MODE mode, FSFILE* filePtr )
	{
 	//----------------------------------------------------------------
	// Validate conditions and parameters
 	//----------------------------------------------------------------
 	if (!SDFS_InitStatus)
 		return CE_NOT_INIT;		// FS is not initialized!
 	if (NULL == FileName)
 		return CE_INVALID_ARGUMENT;		
 	if (NULL == filePtr)
 		return CE_INVALID_ARGUMENT;		
	//-----------------------------------------------------------------
	
	CETYPE 	RC			= CE_GOOD;
	char	fmtName[NAME_SIZE_8r3];
	
	//-----------------------------------------------------------------
	// Validate new name and convert it to 8.3 FAT format
	//-----------------------------------------------------------------
	if ( !SDFS_Format8dot3Name(FileName, fmtName, FALSE) )
		return CE_INVALID_FILENAME;

 	//================================================================
 	// Make sure that the name provided is unique...
 	//----------------------------------------------------------------
 	FS_SeekStart(&SDFS_CWD);		// Rewind Current Working Directory
 	RC = SDFS_DirFindNext(&SDFS_CWD, filePtr, ATTR_NONE,  ATTR_NONE, fmtName);
 	//----------------------------------------------------------------
 	if (CE_EOF == RC)
 		// There is no object with the same name
 		goto NotFound;
 	//----------------------------------------------------------------			
 	if (CE_GOOD != RC)
 		// Some other error (except for CE_EOF) had happened...
 		return RC;
 	//----------------------------------------------------------------			
 	if ( FS_IsDirectory(filePtr) )
 		// The object found is a Directory...
 		{
	 	SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE);	// Reset output FSFILE structure
	 	return CE_FILENAME_EXISTS;
 		}
 	//----------------------------------------------------------------			


 	//================================================================
 	// The file with the specified name present on the disk...
 	//----------------------------------------------------------------
	switch(mode)
       	{
		case FS_CREATE_NEW:
            // File exists, we want to create a new one, so remove it first
            if ( CE_GOOD != (RC = FS_Delete(filePtr)) )
            	// Delete failed...
            	{
		 		SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE);	// Reset output FSFILE structure
            	return RC;
            	}
            //-----------------------------------------
            // Nope, does not exist any more :)
            goto NotFound;

               	
		case FS_APPEND:
            // File exists, we want to position it at the end
            if ( CE_GOOD != (RC = FS_SeekEnd(filePtr)) )
            	// Seek failed...
            	{
		 		SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE);	// Reset output FSFILE structure
            	return RC;
            	}
            //-----------------------------------------
            // Everything is fine!
            return CE_GOOD;
            

		case FS_READ_ONLY:
			// Set READONLY attribute on the FO data structure to prevent WRITEs
			filePtr->dirFileEntry.DIR_Attr |= ATTR_READONLY;
			// Fall-through to OPEN_EXISTING
		case FS_OPEN_EXISTING:
			FS_SeekStart(filePtr);
			return CE_GOOD;
			
			
		default:
	 		SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE);	// Reset output FSFILE structure
           	return CE_INVALID_ARGUMENT;
       	}


 	//================================================================
 	// The file with the specified name does not exist on disk...
 	//----------------------------------------------------------------
 NotFound:
	switch(mode)
       	{
		case FS_CREATE_NEW:
		case FS_APPEND:
		case FS_OPEN_EXISTING:
			// For all of the cases above proceed to creating new file
			break;
			

		case FS_READ_ONLY:
			// Bad luck...
	 		SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE);	// Reset output FSFILE structure
           	return CE_NOT_FOUND;
			
			
		default:
	 		SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE);	// Reset output FSFILE structure
           	return CE_INVALID_ARGUMENT;
       	}


 	//================================================================
 	// Now it is time to create a new file
 	//----------------------------------------------------------------
 	// First, try to create Directory Entry
 	//----------------------------------------------------------------
 	if ( (RC = SDFS_DirFindEmpty(&SDFS_CWD, filePtr)) != CE_GOOD)
 		return RC;		// Could not create directory entry...
 	//----------------------------------------------------------------
 	// Second, allocate a cluster to the file
 	//----------------------------------------------------------------
 	if ( CE_GOOD != (RC = SDFS_ClusterAllocateNew(filePtr)) )
 		{
 		SDFS_InitFSFILE(filePtr, NULL, ATTR_NONE);	// Reset output FSFILE structure
	 	return RC;	
 		}
 	//----------------------------------------------------------------
 	// Third, set the name and Attributes of the new entry
 	//----------------------------------------------------------------
 	memcpy(filePtr->dirFileEntry.DIR_Name, fmtName, NAME_SIZE_8r3);
 	filePtr->dirFileEntry.DIR_Attr = ATTR_ARCHIVE;	
 	//----------------------------------------------------------------
 	// That's basically it - just need to save changes to disk
 	//----------------------------------------------------------------
 	return FS_Flush(filePtr);
	}
예제 #7
0
//*************************************************************************************
//  Function:		CETYPE FS_mkDir (char * Name, ATTR_TYPE Attr, FSFILE* newDir)
//-------------------------------------------------------------------------------------
//  Summary:		Creates directory with the specified name in the current working
//					directory.
//  Input:			
//					Name	- Name of the new directory
//					Attr	- Additional attributes of the new directory
//					newDir	- pointer to the File Object structure that on SUCCESS
//							  will be set to the newly created directory.
//  Return Values:
//					CETYPE enum member (expected CE_GOOD)
//					Other codes depending on encountered error conditions
//*************************************************************************************
CETYPE FS_mkDir (char * Name, ATTR_TYPE Attr, FSFILE* newDir)
	{
 	//----------------------------------------------------------------
	// Validate conditions and parameters
 	//----------------------------------------------------------------
 	if (!SDFS_InitStatus)
 		return CE_NOT_INIT;		// FS is not initialized!
 	if (NULL == Name)
 		return CE_INVALID_FILENAME;		
 	if (NULL == newDir)
 		return CE_INVALID_ARGUMENT;		
 	//----------------------------------------------------------------
 	char	fmtName[NAME_SIZE_8r3];
 	CETYPE	RC;
 	//----------------------------------------------------------------
 	// Verify/Format provided Directory name (for direct match)
 	//----------------------------------------------------------------
 	if ( !SDFS_Format8dot3Name (Name, fmtName, FALSE) )
 		return CE_INVALID_FILENAME;	// Invalid/missing name
 	//----------------------------------------------------------------
 	// Make sure that the name provided is unique...
 	//----------------------------------------------------------------
 	FS_SeekStart(&SDFS_CWD);		// Rewind Current Working Directory
 	RC = SDFS_DirFindNext(&SDFS_CWD, newDir, ATTR_NONE,  ATTR_NONE, fmtName);
 	//----------------------------------------------------------------
 	if (CE_GOOD == RC)
 		{
	 	if ( FS_IsDirectory(newDir) )
	 		// Directory with the same name is found...
	 		return CE_GOOD;
	 	else
	 		// There exists file with the same name...
	 		{
		 	SDFS_InitFSFILE(newDir, NULL, ATTR_NONE);	// Reset output FSFILE structure
		 	return CE_FILENAME_EXISTS;
	 		}
 		}
 	if (CE_EOF != RC)
 		return RC;		// Some other error happend on the way...
 	//----------------------------------------------------------------
 	// The name provided is unique; Try to create Directory Entry
 	//----------------------------------------------------------------
 	if ( (RC = SDFS_DirFindEmpty(&SDFS_CWD, newDir)) != CE_GOOD)
 		return RC;		// Could not create directory entry...
 	//----------------------------------------------------------------
 	// Success; Set the name and Attributes of the new entry
 	//----------------------------------------------------------------
 	memcpy(newDir->dirFileEntry.DIR_Name, fmtName, NAME_SIZE_8r3);
 	newDir->dirFileEntry.DIR_Attr = ATTR_DIRECTORY | ATTR_ARCHIVE;	
 	//----------------------------------------------------------------
 	// Allocate a cluster for the new Directory and create mandatory
 	// "." and ".." entries
 	//----------------------------------------------------------------
 	if ( (RC = SDFS_ClusterAllocateNew(newDir)) != CE_GOOD)
 		// Failure allocating cluster...
 		{
	 	SDFS_InitFSFILE(newDir, NULL, ATTR_NONE);	// Reset output FSFILE structure
	 	return RC;
 		}
 	//----------------------------------------------------------------
 	DIRENTRY	spcDir;
 	DWORD		dirCluster;
 	// Set template Directory record for "." and ".." entries
 	SDFS_DirResetEntry(	&spcDir, NULL, ATTR_DIRECTORY);
 	//----------------------------------------------------------------
 	// Create and store "." entry
 	//----------------------------------------------------------------
 	spcDir.DIR_Name[0] = '.';
 	dirCluster = SDFS_DirGetFirstCluster(&newDir->dirFileEntry);
 	SDFS_DirSetFirstCluster (&spcDir, dirCluster);
 	FS_Write(newDir, &spcDir, sizeof(DIRENTRY));
 	//----------------------------------------------------------------
 	// Create and store ".." entry
 	//----------------------------------------------------------------
 	spcDir.DIR_Name[1] = '.';
 	dirCluster = SDFS_DirGetFirstCluster(&SDFS_CWD.dirFileEntry);
 	if (dirCluster == SDFS_VolumeInfo.rootClsN)
 		// Parent is the Root directory of the volume
 		dirCluster = 0; // FAT32 rule for pointers to Root
 	SDFS_DirSetFirstCluster (&spcDir, dirCluster);
 	FS_Write(newDir, &spcDir, sizeof(DIRENTRY));
 	//----------------------------------------------------------------
 	return FS_Flush(newDir);
	}