hfatdent.c

HFAT32是我依据FAT标准,按照自己的理解写出来的一个FAT文件系统 特性: 1.HFAT32 是一个小型的嵌入式FAT文件系统,可以方便地在nand flash,RAM和SD Card

	{
		if (_hai_FatDevRead(dev, RootSec, SecBuf))
			return FATERR_DEV_OPERATE_ERR;
		for (pSecBuf = SecBuf; (pSecBuf-SecBuf)<DevInf_BytsPerSec(dev);pSecBuf += FAT_DIRENT_SIZE)
		{
			if (*pDIR_Name(pSecBuf)==EMPTY_DIR_FLAG)//finish
				return FATERR_INVALID_PATH;
			else if (*pDIR_Name(pSecBuf)==DELETED_DIR_FLAG)//invalid dir entry
				;
			else if ((*pLDIR_Attr(pSecBuf)&FILE_ATTR_LONG_NAME_MASK)==FILE_ATTR_LONG_NAME)//long name sub-component
				;
			else if ((*pDIR_Attr(pSecBuf)&(FILE_ATTR_DIRECTORY|FILE_ATTR_VOLUME_ID)) == 0x00)// find a file
			{
				hai_memcpy(dentbuf, pSecBuf, FAT_DIRENT_SIZE);
				hai_GetFileNameFromDent(dentbuf, tmpname);
				if (!hai_stricmp(Name83, tmpname))
					return 0;						
			}
			else if ((*pDIR_Attr(pSecBuf)&(FILE_ATTR_DIRECTORY|FILE_ATTR_VOLUME_ID)) == FILE_ATTR_DIRECTORY)// find a directory
			{
				hai_memcpy(dentbuf, pSecBuf, FAT_DIRENT_SIZE);
				hai_GetFileNameFromDent(dentbuf, tmpname);
				if (!hai_stricmp(Name83, tmpname))
					return 0;						
			}
			else if ((*pDIR_Attr(pSecBuf)&(FILE_ATTR_DIRECTORY|FILE_ATTR_VOLUME_ID)) == FILE_ATTR_VOLUME_ID)// find a volume lab
				;
			else
				;// illegal dir entry
		}
	}

	return FATERR_INVALID_PATH;

}

int hai_FindShortName(int dev, S_DWORD StartClust, S_BYTE *Name83, S_BYTE *dentbuf)
{
	int err = FATERR_INVALID_PATH;
	S_DWORD SecStart, SecEnd;
	S_BYTE *pSecBuf;
	S_BYTE SecBuf[FAT_SEC_BUF_MAX];
	S_BYTE tmpname[HAI_FILENAME_MAX+4];

	if (DevInf_FatType(dev)== FAT_TYPE_16 && StartClust == 0)
		return hai_FindShortNameOnFAT16Root(dev, Name83, dentbuf);

	if (StartClust == 0) // FAT32 rootclust
		StartClust = DevInf_RootClus(dev);

	hai_memset(tmpname, 0x00, sizeof(tmpname));

	while (DevInf_FatType(dev)==FAT_TYPE_16?IS_FAT16_INUSE_CLUST(StartClust):IS_FAT32_INUSE_CLUST(StartClust))
	{
		SecStart = DevInf_FirstDatSec(dev) + (StartClust-2)*DevInf_SecPerClust(dev);//get first sec of clust;
		for (SecEnd = SecStart+DevInf_SecPerClust(dev); SecStart < SecEnd; SecStart++)
		{
			if (_hai_FatDevRead(dev, SecStart, SecBuf))
				return FATERR_DEV_OPERATE_ERR;
			for (pSecBuf = SecBuf; (pSecBuf-SecBuf)<DevInf_BytsPerSec(dev);pSecBuf += FAT_DIRENT_SIZE)
			{
				if (*pDIR_Name(pSecBuf)==EMPTY_DIR_FLAG)//finish
					return FATERR_INVALID_PATH;
				else if (*pDIR_Name(pSecBuf)==DELETED_DIR_FLAG)//invalid dir entry
					;
				else if ((*pLDIR_Attr(pSecBuf)&FILE_ATTR_LONG_NAME_MASK)==FILE_ATTR_LONG_NAME)//long name sub-component
					;
				else if ((*pDIR_Attr(pSecBuf)&(FILE_ATTR_DIRECTORY|FILE_ATTR_VOLUME_ID)) == 0x00)// find a file
				{
					hai_memcpy(dentbuf, pSecBuf, FAT_DIRENT_SIZE);
					hai_GetFileNameFromDent(dentbuf, tmpname);
					if (!hai_stricmp(Name83, tmpname))
						return 0;						
				}
				else if ((*pDIR_Attr(pSecBuf)&(FILE_ATTR_DIRECTORY|FILE_ATTR_VOLUME_ID)) == FILE_ATTR_DIRECTORY)// find a directory
				{
					hai_memcpy(dentbuf, pSecBuf, FAT_DIRENT_SIZE);
					hai_GetFileNameFromDent(dentbuf, tmpname);
					if (!hai_stricmp(Name83, tmpname))
						return 0;						
				}
				else if ((*pDIR_Attr(pSecBuf)&(FILE_ATTR_DIRECTORY|FILE_ATTR_VOLUME_ID)) == FILE_ATTR_VOLUME_ID)// find a volume lab
					;
				else
					;// illegal dir entry
			}
		}
		StartClust = hai_GetNextCluster(dev, StartClust);
	}
	
	return err;
}

S_DWORD hai_AllocDentOnFAT16Root(int dev, int DentCnt, S_WORD *DentNum)
{
	int cnt = 0;
	S_BYTE *pSecBuf, SecBuf[FAT_SEC_BUF_MAX];
	S_DWORD SecNum = 0;
	S_DWORD RootSec = DevInf_RsvdSec(dev)+DevInf_NumFats(dev)*DevInf_FatSize(dev);
	S_DWORD RootSiz = ((DevInf_RootEntCnt(dev)*FAT_DIRENT_SIZE)+(DevInf_BytsPerSec(dev)-1))/DevInf_BytsPerSec(dev);

	for (RootSiz += RootSec; RootSec < RootSiz; RootSec++)
	{
		if (_hai_FatDevRead(dev, RootSec, SecBuf))
			return 0;
		for (pSecBuf = SecBuf; (pSecBuf-SecBuf)<DevInf_BytsPerSec(dev);pSecBuf += FAT_DIRENT_SIZE)
		{
			if ((*pDIR_Name(pSecBuf)==EMPTY_DIR_FLAG)//finish dir
				|| (*pDIR_Name(pSecBuf)==DELETED_DIR_FLAG))// invalid dir entry
			{
				cnt++;
				if (SecNum == 0)
					SecNum = RootSec, *DentNum = (pSecBuf-SecBuf)/FAT_DIRENT_SIZE;
			}
			else
			{
				cnt = 0, *DentNum = 0, SecNum = 0;
			}
			if (cnt >= DentCnt)
				return SecNum;
		}
	}

	return 0;
}


S_DWORD hai_AllocDent(int dev, S_DWORD StartClust, int DentCnt, S_WORD *DentNum)
{
	int cnt = 0;
	S_BYTE *pSecBuf, SecBuf[FAT_SEC_BUF_MAX];
	S_DWORD SecStart, SecEnd, SecNum = 0;
	S_DWORD TmpClust;

	if (DevInf_FatType(dev) == FAT_TYPE_16 && StartClust == 0)
		return hai_AllocDentOnFAT16Root(dev, DentCnt, DentNum);
	
	if (StartClust == 0) // FAT32 rootclust
		StartClust = DevInf_RootClus(dev);

	while (DevInf_FatType(dev)==FAT_TYPE_16?IS_FAT16_INUSE_CLUST(StartClust):IS_FAT32_INUSE_CLUST(StartClust))
	{
		SecStart = DevInf_FirstDatSec(dev) + (StartClust-2)*DevInf_SecPerClust(dev);//get first sec of clust;
		for (SecEnd = SecStart+DevInf_SecPerClust(dev); SecStart < SecEnd; SecStart++)
		{
			if (_hai_FatDevRead(dev, SecStart, SecBuf))
				return 0;
			for (pSecBuf = SecBuf; (pSecBuf-SecBuf)<DevInf_BytsPerSec(dev);pSecBuf += FAT_DIRENT_SIZE)
			{
				if ((*pDIR_Name(pSecBuf)==EMPTY_DIR_FLAG)//finish
					 || (*pDIR_Name(pSecBuf)==DELETED_DIR_FLAG))//invalid dir entry
				{
					cnt++;
					if (SecNum == 0)
						SecNum = SecStart, *DentNum = (pSecBuf-SecBuf)/FAT_DIRENT_SIZE;
				}
				else
				{
					cnt = 0, *DentNum = 0, SecNum = 0;
				}
				if (cnt >= DentCnt)
					return SecNum;
			}
		}
		StartClust = hai_GetNextCluster(dev, StartClust);
		if (!(DevInf_FatType(dev)==FAT_TYPE_16?IS_FAT16_INUSE_CLUST(StartClust):IS_FAT32_INUSE_CLUST(StartClust)))
		{
			if ((TmpClust = hai_AllocIdleClust(dev)) == 0)
				break;
			if (!hai_LinkClust(dev, StartClust, TmpClust))
				StartClust = TmpClust;
		}
	}

	return 0;
}

int hai_WriteDentOnFat16Root(int dev, S_DWORD SecNum, S_WORD DentNum, const S_BYTE *LongName, S_BYTE *ShortDent)
{
	S_BYTE ChkSum, Order;
	S_WORD num, DentCnt = 1;
	S_BYTE *pSecBuf, SecBuf[FAT_SEC_BUF_MAX];
	S_BYTE UniStr[HAI_FILENAME_MAX+4];

	if (LongName && LongName[0])
	{
		DentCnt += (S_WORD)((hai_CountChar(LongName)+LDIR_STR_CHAR_MAX-1)/LDIR_STR_CHAR_MAX);
		ChkSum = hai_ShortFileNameChkSum(ShortDent);
		hai_OtherCode2Unicode(UniStr, LongName);
	}
	
	if (_hai_FatDevRead(dev, SecNum, SecBuf))
		return FATERR_DEV_OPERATE_ERR;
	pSecBuf = SecBuf+DentNum*FAT_DIRENT_SIZE;

	for (num = DentCnt; num > 0; num--)
	{
		if (pSecBuf == SecBuf+DevInf_BytsPerSec(dev))
		{
			if (_hai_FatDevWrite(dev, SecNum, SecBuf))
				return FATERR_DEV_OPERATE_ERR;
			if (_hai_FatDevRead(dev, ++SecNum, SecBuf))
				return FATERR_DEV_OPERATE_ERR;
			pSecBuf = SecBuf;
		}
		if (num == 1)
		{
			hai_memcpy(pSecBuf, ShortDent, FAT_DIRENT_SIZE);
			pSecBuf += FAT_DIRENT_SIZE;
		}
		else
		{
			Order = num - 1;
			if (num == DentCnt)
				Order |= LDIR_LAST_LONG_ENTRY;
			hai_FillLDent(pSecBuf, UniStr+(num-2)*LDIR_STR_BYTE_MAX, ChkSum, Order);
			pSecBuf  += FAT_DIRENT_SIZE;
		}
	}
	if (_hai_FatDevWrite(dev, SecNum, SecBuf))
		return FATERR_DEV_OPERATE_ERR;

	return 0;
}

int hai_WriteDent(int dev, S_DWORD SecNum, S_WORD DentNum, const S_BYTE *LongName, S_BYTE *ShortDent)
{
	S_BYTE Order, ChkSum;
	S_WORD num, DentCnt = 1;
	S_BYTE *pSecBuf, SecBuf[FAT_SEC_BUF_MAX];
	S_DWORD FirstSec, TmpClust;
	S_BYTE UniStr[HAI_FILENAME_MAX+4];

	if (DevInf_FatType(dev) == FAT_TYPE_16)
	{
		TmpClust   = DevInf_RsvdSec(dev)+DevInf_NumFats(dev)*DevInf_FatSize(dev);
		TmpClust += ((DevInf_RootEntCnt(dev)*FAT_DIRENT_SIZE)+(DevInf_BytsPerSec(dev)-1))/DevInf_BytsPerSec(dev);
		if (SecNum < TmpClust)
			return hai_WriteDentOnFat16Root(dev, SecNum, DentNum, LongName, ShortDent);
	}
	
	SecNum -= DevInf_FirstDatSec(dev);
	TmpClust = SecNum/DevInf_SecPerClust(dev) + 2;
	FirstSec = DevInf_FirstDatSec(dev)+(TmpClust-2)*DevInf_SecPerClust(dev);
	SecNum = SecNum%DevInf_SecPerClust(dev);
	
	if (LongName && LongName[0])
	{
		DentCnt += (S_WORD)((hai_CountChar(LongName)+LDIR_STR_CHAR_MAX-1)/LDIR_STR_CHAR_MAX);
		ChkSum = hai_ShortFileNameChkSum(ShortDent);
		hai_OtherCode2Unicode(UniStr, LongName);
	}
	
	if (_hai_FatDevRead(dev, FirstSec+SecNum, SecBuf))
		return FATERR_DEV_OPERATE_ERR;
	pSecBuf = SecBuf+DentNum*FAT_DIRENT_SIZE;

	for (num = DentCnt; num > 0; num--)
	{
		if (pSecBuf == SecBuf+DevInf_BytsPerSec(dev))
		{
			if (_hai_FatDevWrite(dev, FirstSec+SecNum, SecBuf))
				return FATERR_DEV_OPERATE_ERR;
			if (SecNum+1 == DevInf_SecPerClust(dev))//clust end
			{
				TmpClust = hai_GetNextCluster(dev, TmpClust);
				FirstSec = DevInf_FirstDatSec(dev)+(TmpClust-2)*DevInf_SecPerClust(dev);
				SecNum   = 0;
			}
			else
				SecNum++;
			if (_hai_FatDevRead(dev, FirstSec+SecNum, SecBuf))
				return FATERR_DEV_OPERATE_ERR;
			pSecBuf = SecBuf;
		}
		if (num == 1)
		{
			hai_memcpy(pSecBuf, ShortDent, FAT_DIRENT_SIZE);
			pSecBuf += FAT_DIRENT_SIZE;
		}
		else
		{
			Order = num - 1;
			if (num == DentCnt)
				Order |= LDIR_LAST_LONG_ENTRY;
			hai_FillLDent(pSecBuf, UniStr+(num-2)*LDIR_STR_BYTE_MAX, ChkSum, Order);
			pSecBuf  += FAT_DIRENT_SIZE;
		}
	}
	if (_hai_FatDevWrite(dev, FirstSec+SecNum, SecBuf))
		return FATERR_DEV_OPERATE_ERR;

	return 0;
}

int hai_InitDirectory(int dev, S_DWORD CurClus, S_DWORD PreClus)
{
	S_BYTE SecBuf[FAT_SEC_BUF_MAX];
	S_DWORD SecNum;

	if (DevInf_FatType(dev) == FAT_TYPE_32 && PreClus == DevInf_RootClus(dev))
		PreClus = 0;

	hai_memset(SecBuf, 0x00, sizeof(SecBuf));
	//init dent .
	hai_FillDent(SecBuf, "", FILE_ATTR_DIRECTORY|FILE_ATTR_READ_ONLY, 0x00, CurClus);
	*pDIR_Name(SecBuf) = '.'; 
	//init dent ..
	hai_FillDent(SecBuf+FAT_DIRENT_SIZE, "", FILE_ATTR_DIRECTORY|FILE_ATTR_READ_ONLY, 0x00, PreClus);
	*(pDIR_Name(SecBuf)+FAT_DIRENT_SIZE) = '.'; 
	*(pDIR_Name(SecBuf)+FAT_DIRENT_SIZE+1) = '.';

	SecNum = DevInf_FirstDatSec(dev) + (CurClus-2)*DevInf_SecPerClust(dev);
	if (_hai_FatDevWrite(dev, SecNum, SecBuf))
		return FATERR_DEV_OPERATE_ERR;
#if 0
	hai_memset(SecBuf, 0x00, sizeof(SecBuf));
	for (Sec = 1; Sec < DevInf_SecPerClust(dev); Sec++)
	{
		if (_hai_FatDevWrite(dev, SecNum+Sec, SecBuf))
			return FATERR_DEV_OPERATE_ERR;
	}
#endif	
	return 0;
}

int hai_CreateDirDent(int dev, S_DWORD StartClust, S_BYTE *pName, S_BYTE *dentbuf)