yaffsfsd.c

嵌入式linux yaffs文件系统源代码

			fc.uFlags = SHCNF_PATH;
			fc.dwItem1 = (DWORD)yfsd_FullPathName(pVolume,fpn,YFSD_FULL_PATH_NAME_SIZE,pathName);
			fc.dwItem2 = 0;
			fc.dwAttributes = 0;
			yfsd_NullWinFileTime(&fc.ftModified);
			fc.nFileSize = 0;

			pVolume->shellFunction(&fc);
			RETAILMSG (MSGSTATE, (L"YAFFS::shell function called\r\n"));

			yfsd_ShellDirectoryChanged(pVolume,fpn);
	}
	
	return result ? TRUE : FALSE;
}


DWORD YFSD_GetFileAttributesW(PVOLUME pVolume, PCWSTR pwsFileName )
{
	yaffs_Object *obj = NULL;

	DWORD result = 0xFFFFFFFF;

	RETAILMSG (MSGSTATE, (L"YAFFS::GetFileAttributes\r\n"));

	yfsd_LockYAFFS();

	obj = yfsd_FindObjectByWinPath(&pVolume->dev,pwsFileName);

	if(obj)
	{
		result = yfsd_GetObjectWinAttributes(obj);
	}
	else
	{
		SetLastError(ERROR_FILE_NOT_FOUND);
	}

	yfsd_UnlockYAFFS();
	
	RETAILMSG (MSGSTATE, (L"YAFFS::GetFileAttributes for %s returning %X\r\n",pwsFileName,result));
	return result;

	
}

BOOL YFSD_SetFileAttributesW( PVOLUME pVolume,PCWSTR pwsFileName, DWORD dwFileAttributes )
{
	yaffs_Object *obj = NULL;
	DWORD mtime[2];
	DWORD attribs;
	DWORD objSize;

	int result = 0;

	RETAILMSG (MSGSTATE, (L"YAFFS::SetFileAttributes %X\r\n",dwFileAttributes));

	if(!yfsd_CheckValidAttributes(dwFileAttributes))
	{
			SetLastError(ERROR_INVALID_PARAMETER);
			return FALSE;
	}

	yfsd_LockYAFFS();

	obj = yfsd_FindObjectByWinPath(&pVolume->dev,pwsFileName);

	if(obj)
	{
		obj->st_mode = dwFileAttributes;
		obj->dirty = 1;
		result = yaffs_FlushFile(obj,0);
		attribs = yfsd_GetObjectWinAttributes(obj);
		objSize = yaffs_GetObjectFileLength(obj);
		mtime[0] = obj->win_mtime[0];
		mtime[1] = obj->win_mtime[1];
	}
	else
	{
		SetLastError(ERROR_FILE_NOT_FOUND);
	}

	yfsd_UnlockYAFFS();

	if(result && pVolume->shellFunction)
	{
			FILECHANGEINFO fc;
			WCHAR fpn[YFSD_FULL_PATH_NAME_SIZE];

			fc.cbSize = sizeof(FILECHANGEINFO);
			fc.wEventId = SHCNE_ATTRIBUTES;
			fc.uFlags = SHCNF_PATH;
			fc.dwItem1 = (DWORD)yfsd_FullPathName(pVolume,fpn,YFSD_FULL_PATH_NAME_SIZE,pwsFileName);
			fc.dwItem2 = 0;
			fc.dwAttributes =  attribs;
			yfsd_U32sToWinFileTime(mtime,&fc.ftModified);
			fc.nFileSize = objSize;

			pVolume->shellFunction(&fc);
			RETAILMSG (MSGSTATE, (L"YAFFS::shell function called\r\n"));

			//yfsd_ShellDirectoryChanged(pVolume,fpn);
	}
	

	return result;

}

BOOL YFSD_DeleteFileW( PVOLUME pVolume, PCWSTR pwsFileName )
{
	int result = FALSE;
	yaffs_Object *parent = NULL;
	yaffs_Object *obj;
	char name[YFSD_NAME_LENGTH+1];

	RETAILMSG (MSGSTATE, (L"YAFFS::DeleteFileW (%s)\r\n", pwsFileName));

	yfsd_LockYAFFS();

	obj = yfsd_FindObjectByWinPath(&pVolume->dev,pwsFileName);
	if(!obj)
	{
		SetLastError(ERROR_FILE_NOT_FOUND);
		result = FALSE;
	}
	else if (obj->variantType != YAFFS_OBJECT_TYPE_FILE)
	{
		SetLastError(ERROR_ACCESS_DENIED);
		result = FALSE;
	}
	else if(obj->st_mode & FILE_ATTRIBUTE_READONLY)
	{
		SetLastError(ERROR_ACCESS_DENIED);
		result = FALSE;
	}
	else if(obj->inUse)
	{
		SetLastError(ERROR_ACCESS_DENIED);
		result = FALSE;
	}
	else
	{

		parent = yfsd_FindDirectoryByWinPath(&pVolume->dev,pwsFileName,name,YFSD_NAME_LENGTH);

		if(parent && yfsd_NameIsValid(name))
		{
			result = yaffs_Unlink(parent,name);
			if(!result)
				SetLastError(ERROR_ACCESS_DENIED);
		}
	}

	yfsd_UnlockYAFFS();

	if(result && pVolume->shellFunction)
	{
			FILECHANGEINFO fc;
			WCHAR fpn[YFSD_FULL_PATH_NAME_SIZE];

			fc.cbSize = sizeof(FILECHANGEINFO);
			fc.wEventId = SHCNE_DELETE;
			fc.uFlags = SHCNF_PATH;
			fc.dwItem1 = (DWORD)yfsd_FullPathName(pVolume,fpn,YFSD_FULL_PATH_NAME_SIZE,pwsFileName);
			fc.dwItem2 = 0;
			fc.dwAttributes = -1;
			yfsd_NullWinFileTime(&fc.ftModified);
			fc.nFileSize = 0;

			pVolume->shellFunction(&fc);
			RETAILMSG (MSGSTATE, (L"YAFFS::shell function called\r\n"));

			yfsd_ShellDirectoryChanged(pVolume,fpn);
	}

	return result ? TRUE : FALSE;
}

BOOL YFSD_MoveFileW(PVOLUME pVolume,PCWSTR pwsOldFileName, PCWSTR pwsNewFileName )
{
	yaffs_Object *newParent = NULL;
	yaffs_Object *oldParent = NULL;
	yaffs_Object *obj = NULL;
	char oldName[YFSD_NAME_LENGTH+1];
	char newName[YFSD_NAME_LENGTH+1];
	int result = 0;
	int objIsDir = 0;
	DWORD attribs;
	DWORD objSize;
	DWORD mtime[2];

	RETAILMSG (MSGSTATE, (L"YAFFS::MoveFile\r\n"));

	yfsd_LockYAFFS();

	oldParent = yfsd_FindDirectoryByWinPath(&pVolume->dev,pwsOldFileName,oldName,YFSD_NAME_LENGTH);
	newParent = yfsd_FindDirectoryByWinPath(&pVolume->dev,pwsNewFileName,newName,YFSD_NAME_LENGTH);

	if(oldParent  && yfsd_NameIsValid(oldName) && newParent && yfsd_NameIsValid(newName))
	{
		result = yaffs_RenameObject(oldParent,oldName,newParent,newName);
		if(!result)
		{
			SetLastError(ERROR_FILE_NOT_FOUND);
		}

		obj = yfsd_FindObjectByWinPath(&pVolume->dev,pwsNewFileName);
		if(obj)
		{
			objIsDir = (obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY);
			attribs = yfsd_GetObjectWinAttributes(obj);
			objSize = yaffs_GetObjectFileLength(obj);
			mtime[0] = obj->win_mtime[0];
			mtime[1] = obj->win_mtime[1];
		}
	}
	else
	{
		SetLastError(ERROR_PATH_NOT_FOUND);
	}

	yfsd_UnlockYAFFS();


	if(result && pVolume->shellFunction)
	{
			FILECHANGEINFO fc;
			WCHAR fpn1[YFSD_FULL_PATH_NAME_SIZE];
			WCHAR fpn2[YFSD_FULL_PATH_NAME_SIZE];

			fc.cbSize = sizeof(FILECHANGEINFO);
			fc.wEventId = objIsDir ? SHCNE_RENAMEFOLDER : SHCNE_RENAMEITEM;
			fc.uFlags = SHCNF_PATH;
			fc.dwItem1 = (DWORD)yfsd_FullPathName(pVolume,fpn1,YFSD_FULL_PATH_NAME_SIZE,pwsOldFileName);
			fc.dwItem2 = (DWORD)yfsd_FullPathName(pVolume,fpn2,YFSD_FULL_PATH_NAME_SIZE,pwsNewFileName);
			fc.dwAttributes = attribs;
			yfsd_U32sToWinFileTime(mtime,&fc.ftModified);
			fc.nFileSize = objSize;

			pVolume->shellFunction(&fc);
			RETAILMSG (MSGSTATE, (L"YAFFS::shell function called\r\n"));

			yfsd_ShellDirectoryChanged(pVolume,fpn1);
			yfsd_ShellDirectoryChanged(pVolume,fpn2);
	}


	return result ? TRUE : FALSE;

}

BOOL YFSD_DeleteAndRenameFileW(PVOLUME pVolume, PCWSTR pwsOldFileName, PCWSTR pwsNewFileName )
{
	//slf021104c begin
    BOOL fSuccess;
	//slf021104c end

	RETAILMSG (MSGSTATE, (L"YAFFS::DeleteAndRename\r\n"));

	//slf021104c begin
    if (fSuccess = YFSD_DeleteFileW(pVolume, pwsOldFileName))
        fSuccess = YFSD_MoveFileW(pVolume, pwsNewFileName, pwsOldFileName);
	return fSuccess;
	//return FALSE;
	//slf021104c end
}

BOOL YFSD_GetDiskFreeSpaceW( PVOLUME pVolume, PCWSTR pwsPathName, PDWORD pSectorsPerCluster,PDWORD pBytesPerSector, PDWORD pFreeClusters, PDWORD pClusters )
{

	int nChunks;

	RETAILMSG (MSGSTATE, (L"YAFFS::GetFreeSpace\r\n"));

	yfsd_LockYAFFS();
	nChunks = yaffs_GetNumberOfFreeChunks(&pVolume->dev);
	yfsd_UnlockYAFFS();

	if(nChunks >= 0)
	{
		// Let's pretentd our clusters are the same size as eraseable blocks...
		*pBytesPerSector = 512;
		*pSectorsPerCluster  =32;
		*pFreeClusters = nChunks/32;
		*pClusters = pVolume->dev.endBlock - pVolume->dev.startBlock + 1;
	}

	return (nChunks >= 0)? TRUE : FALSE;



}

void YFSD_Notify(PVOLUME pVolume, DWORD dwFlags )
{
	// Flags can be one of:
	// FSNOTIFY_POWER_ON: no action required
	// FSNOTIFY_POWER_OFF: flush all files
	// FSNOTIFY_DEVICE_ON: no action required

	RETAILMSG (MSGSTATE, (L"YAFFS::Notify\r\n"));
	if(dwFlags == FSNOTIFY_POWER_OFF)
	{
		yfsd_FlushAllFiles();
	}

}


BOOL YFSD_RegisterFileSystemFunction(PVOLUME pVolume,SHELLFILECHANGEFUNC_t pfn )
{
	RETAILMSG (MSGSTATE, (L"YAFFS::RegisterFileSysFunction\r\n"));
	
	pVolume->shellFunction = pfn;

	return TRUE;
}





int iMatch(const char a, const char b)
{
	if (a == '?' || b == '?')
		return 1;
	return (toupper(a) == toupper(b));
}

void pString(const char *inp)
{
	while (*inp) RETAILMSG(1, (L"%c", *inp++));
}

int regularMatch(const char *regexp, const char *str)
{
//	pString(regexp);
//	RETAILMSG(1, (L" "));
//	pString(str);
//	RETAILMSG(1, (L"\r\n"));

	if (*regexp == 0 && *str == 0)
	{
		//RETAILMSG(1, (L"Match!\r\n"));
		return 1;
	}
	if (*regexp == '*')			
	{
		regexp++;
		if (*regexp == 0)   // end of the expression is a *, we must match
		{
			//RETAILMSG(1, (L"Match!\r\n"));
			return 1;
		}
		while (!iMatch(*regexp, *str)) // throw away chars from str until we match
		{
			if (*str == 0)  // if we're not at the end
			{
				// if we have .* left to match, but the str is finished then match it OK
				if (regexp[0] == '.' && regexp[1] == '*')
				{
					//RETAILMSG(1, (L"Match!\r\n"));
					return 1;
				}
				else
				{
				// the extension failed the match
					//RETAILMSG(1, (L"No Match!\r\n"));
					return 0;
				}
			}
			str++;
		} 
		// right now we should either eat more characters, or try to match
		return (regularMatch(regexp, str) || regularMatch(--regexp, ++str));
	}
//  compare chars until we hit another *, or we fail
	while (iMatch(*regexp, *str))
	{
		if (*regexp == 0 && *str == 0)
		{
			//RETAILMSG(1, (L"Match!\r\n"));
			return 1;
		}
		regexp++;
		str++;
	}

	if (*regexp == 0 && *str == 0)
	{
		//RETAILMSG(1, (L"Match!\r\n"));
		return 1;
	}

	if (*regexp == '*')
		return regularMatch(regexp, str);

	//RETAILMSG(1, (L"No Match!\r\n"));
	return 0;
}


void yfsd_DeleteFinder(PSEARCH pSearch)
{
  if(pSearch->foundObjects) //If we found some objects we must clean up the cached linked list.
  {
    yaffs_FoundObject *it;
    yaffs_FoundObject *temp;

    it = pSearch->foundObjects;

    while(it != NULL)
    {
      temp = it;
      it = it->next;
      
      free(temp);
    }

    pSearch->foundObjects = NULL;
  }

		pSearch->dir->inUse--;
		free(pSearch);
}

BOOL yfsd_ObjectAlreadyFound(PSEARCH pSearch, yaffs_Object *l)
{
  //Iterate through the current list of objs already found and return true if already exists.
  //If the object hasn't already been found then add it to the list (SIDE-EFFECT alert) and return false.
  BOOL found = FALSE;

  yaffs_FoundObject *it;
  it = pSearch->foundObjects;

  
  while(it->next != NULL) //iterate through singly linked list.
  {
    if(it->obj == l)
    {
      found = TRUE;
      break;
    }
    it = it->next;
  }

  if(!found)
  {
    //Add the item to the list.
    //'it' will currently be pointing to the last of the list nodes. i.e node->next == NULL
    it->next = malloc(sizeof(yaffs_FoundObject));
    it->next->next = NULL;
    it->next->obj = 0;

    it->obj = l;
  }

  return found;
}

#if 0
// slower one
BOOL yfsd_DoFindFile(PSEARCH pSearch, PWIN32_FIND_DATAW pfd)
{

	struct list_head *i;
	int pos;
	yaffs_Object *l;
	BOOL found = 0;

	char name[YAFFS_MAX_NAME_LENGTH+1];

  if(!pSearch->foundObjects)
  {
    pSearch->foundObjects = malloc(sizeof(yaffs_FoundObject));
    pSearch->foundObjects->next = NULL;
    pSearch->foundObjects->obj = 0;
  }


	yfsd_LockYAFFS();

	pos = 0;
	list_for_each(i,&pSearch->dir->variant.directoryVariant.children)
	{

		l = list_entry(i, yaffs_Object,siblings);

		yaffs_GetObjectName(l,name,YAFFS_MAX_NAME_LENGTH+1);

		if(regularMatch(pSearch->pattern,name))
		{
			if(!yfsd_ObjectAlreadyFound(pSearch, l))//pos == pSearch->currentPos)
			{		

				
				found = 1;
				//pSearch->currentPos++;

				// fill out find data

				pfd->dwFileAttributes = yfsd_GetObjectWinAttributes(l);

				yfsd_U32sToWinFileTime(l->win_ctime,&pfd->ftCreationTime);
				yfsd_U32sToWinFileTime(l->win_atime,&pfd->ftLastAccessTime);
				yfsd_U32sToWinFileTime(l->win_mtime,&pfd->ftLastWriteTime);

				pfd->nFileSizeHigh = 0;
				pfd->nFileSizeLow = yaffs_GetObjectFileLength(l);
				pfd->dwOID = (CEOID)(INVALID_HANDLE_VALUE); // wtf is this???

				MultiByteToWideChar(CP_ACP,0,name,-1,pfd->cFileName,YFSD_NAME_LENGTH);

				RETAILMSG(MSGSTATE,(L"File %s id %d header %d nDataChunks %d scannedLength %d\r\n",
							pfd->cFileName,l->objectId, l->chunkId, l->nDataChunks,
							l->variant.fileVariant.scannedFileSize));
				goto out_of_here;
			}
			else
			{
				pos++;
			}
		}
	}

out_of_here:
	yfsd_UnlockYAFFS();


	if(!found)
	{
		SetLastError(ERROR_NO_MORE_FILES);
	}
	return found;
	
}

#else
// faster one
BOOL yfsd_DoFindFile(PSEARCH pSearch, PWIN32_FIND_DATAW pfd)
{

	struct list_head *i;
	yaffs_Object *l;
	BOOL found = 0;

	char name[YAFFS_MAX_NAME_LENGTH+1];

  if(!pSearch->foundObjects)
  {
    pSearch->foundObjects = malloc(sizeof(yaffs_FoundObject));
    pSearch->foundObjects->next = NULL;
    pSearch->foundObjects->obj = 0;
  }


	yfsd_LockYAFFS();

	list_for_each(i,&pSearch->dir->variant.directoryVariant.children)
	{

		l = list_entry(i, yaffs_Object,siblings);
		if(!yfsd_ObjectAlreadyFound(pSearch,l))
		{
			// Only look at things we have not looked at already
			yaffs_GetObjectName(l,name,YAFFS_MAX_NAME_LENGTH+1);

			if(regularMatch(pSearch->pattern,name))
			{
				found = 1;
				// fill out find data