filelib.c

深圳市微逻辑电子有限公司 巨果&#8226 Kingmos&reg 系统核心

#include <eframe.h>
#include <efile.h>
#include <eufile.h>
#include <eapisrv.h>

#include <epcore.h>


typedef BOOL ( WINAPI * PFILE_CREATEDIRECTORY )( LPCTSTR lpcszPathName, PSECURITY_ATTRIBUTES pSecurityAttributes);
BOOL WINAPI File_CreateDirectory( LPCTSTR lpcszPathName,
								  PSECURITY_ATTRIBUTES pSecurityAttributes)
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_FILESYS, FILE_CREATEDIRECTORY, 2 );
    cs.arg0 = (DWORD)lpcszPathName;
    return (DWORD)CALL_SERVER( &cs, pSecurityAttributes );
#else

	PFILE_CREATEDIRECTORY pCreateDirectory;// = (PRGN_EQUAL)lpRgnAPI[RGN_EQUAL];

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_FILESYS, FILE_CREATEDIRECTORY, &pCreateDirectory, &cs ) )
	{
		lpcszPathName = MapProcessPtr( lpcszPathName, (LPPROCESS)cs.lpvData );
		pSecurityAttributes = MapProcessPtr( pSecurityAttributes, (LPPROCESS)cs.lpvData );

		retv = pCreateDirectory( lpcszPathName, pSecurityAttributes);
		API_Leave(  );
	}
	return retv;
#endif
}

typedef HANDLE ( WINAPI * PFILE_CREATEFILE )( LPCTSTR lpcszFileName, DWORD dwAccess, DWORD dwShareMode, PSECURITY_ATTRIBUTES pSecurityAttributes, DWORD dwCreate, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile );
HANDLE WINAPI File_CreateFile( LPCTSTR lpcszFileName,
							   DWORD dwAccess, 
							   DWORD dwShareMode, 
							   PSECURITY_ATTRIBUTES pSecurityAttributes, 
							   DWORD dwCreate, 
							   DWORD dwFlagsAndAttributes, 
							   HANDLE hTemplateFile )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_FILESYS, FILE_CREATEFILE, 7 );
    cs.arg0 = (DWORD)lpcszFileName;
    return (HANDLE)CALL_SERVER( &cs, dwAccess, dwShareMode, pSecurityAttributes, dwCreate, dwFlagsAndAttributes, hTemplateFile );
#else

	PFILE_CREATEFILE pCreateFile;// = (PRGN_EQUAL)lpRgnAPI[RGN_EQUAL];

	CALLSTACK cs;
	HANDLE   retv = NULL;

	if( API_Enter( API_FILESYS, FILE_CREATEFILE, &pCreateFile, &cs ) )
	{
		lpcszFileName = MapProcessPtr( lpcszFileName, (LPPROCESS)cs.lpvData );
		pSecurityAttributes = MapProcessPtr( pSecurityAttributes, (LPPROCESS)cs.lpvData );

		retv = pCreateFile( lpcszFileName, dwAccess, dwShareMode, pSecurityAttributes, dwCreate, dwFlagsAndAttributes, hTemplateFile );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PFILE_CLOSEFILE )( HFILE );
BOOL WINAPI File_CloseFile( HANDLE hFile )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API_HANDLE( API_FILESYS, FILE_CLOSEFILE, 1 );
    cs.arg0 = (DWORD)hFile ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PFILE_CLOSEFILE pCloseFile;
	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_EnterHandle( API_FILESYS, FILE_CLOSEFILE, &pCloseFile, &cs, &hFile ) )
	{
		retv = pCloseFile( hFile );//HandleToPtr(hFile, OBJ_FILE) );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PFILE_DELETEANDRENAME )( LPCTSTR lpcszNewFileName, LPCTSTR lpcszOldFileName );
BOOL WINAPI File_DeleteAndRename( LPCTSTR lpcszNewFileName, LPCTSTR lpcszOldFileName )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_FILESYS, FILE_DELETEANDRENAME, 2 );
    cs.arg0 = (DWORD)lpcszNewFileName;
    return (DWORD)CALL_SERVER( &cs, lpcszOldFileName );
#else

	PFILE_DELETEANDRENAME pDeleteAndRename;// = (PRGN_EQUAL)lpRgnAPI[RGN_EQUAL];

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_FILESYS, FILE_DELETEANDRENAME, &pDeleteAndRename, &cs ) )
	{
		lpcszNewFileName = MapProcessPtr( lpcszNewFileName, (LPPROCESS)cs.lpvData );
		lpcszOldFileName = MapProcessPtr( lpcszOldFileName, (LPPROCESS)cs.lpvData );

		retv = pDeleteAndRename( lpcszNewFileName, lpcszOldFileName );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PFILE_DELETE )( LPCTSTR lpcszFileName );
BOOL WINAPI File_Delete( LPCTSTR lpcszFileName )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_FILESYS, FILE_DELETE, 1 );
    cs.arg0 = (DWORD)lpcszFileName ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PFILE_DELETE pDelete;// = (PRGN_EQUAL)lpRgnAPI[RGN_EQUAL];

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_FILESYS, FILE_DELETE, &pDelete, &cs ) )
	{
		lpcszFileName = MapProcessPtr( lpcszFileName, (LPPROCESS)cs.lpvData );

		retv = pDelete( lpcszFileName );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PFILE_DEVICEIOCONTROL )( HANDLE hFile, DWORD dwIoControlCode,LPVOID lpInBuf,DWORD nInBufSize,LPVOID lpOutBuf,DWORD nOutBufSize,LPDWORD lpdwBytesReturned,LPOVERLAPPED lpOverlapped );
BOOL WINAPI File_DeviceIoControl( 
                          HANDLE hFile,
                          DWORD dwIoControlCode,
                          LPVOID lpInBuf,
                          DWORD nInBufSize,
                          LPVOID lpOutBuf,
                          DWORD nOutBufSize,
                          LPDWORD lpdwBytesReturned,
                          LPOVERLAPPED lpOverlapped )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API_HANDLE( API_FILESYS, FILE_DEVICEIOCONTROL, 8 );
    cs.arg0 = (DWORD)hFile;
    return (DWORD)CALL_SERVER( &cs, dwIoControlCode, lpInBuf, nInBufSize, lpOutBuf, nOutBufSize, lpdwBytesReturned, lpOverlapped );
#else

	PFILE_DEVICEIOCONTROL pDeviceIoControl;// = (PRGN_EQUAL)lpRgnAPI[RGN_EQUAL];

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_EnterHandle( API_FILESYS, FILE_DEVICEIOCONTROL, &pDeviceIoControl, &cs, &hFile ) )
	{
        lpInBuf = MapProcessPtr( lpInBuf, (LPPROCESS)cs.lpvData );
		lpOutBuf = MapProcessPtr( lpOutBuf, (LPPROCESS)cs.lpvData );
		lpdwBytesReturned = MapProcessPtr( lpdwBytesReturned, (LPPROCESS)cs.lpvData );
		lpOverlapped = MapProcessPtr( lpOverlapped, (LPPROCESS)cs.lpvData );

		retv = pDeviceIoControl( hFile, dwIoControlCode, lpInBuf, nInBufSize, lpOutBuf, nOutBufSize, lpdwBytesReturned, lpOverlapped );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PFILE_FINDCLOSE )( HANDLE hFind );
BOOL WINAPI File_FindClose( HANDLE hFind )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_FILESYS, FILE_FINDCLOSE, 1 );
    cs.arg0 = (DWORD)hFind ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PFILE_FINDCLOSE pFindClose;// = (PRGN_EQUAL)lpRgnAPI[RGN_EQUAL];

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_FILESYS, FILE_FINDCLOSE, &pFindClose, &cs ) )
	{
		retv = pFindClose( hFind );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef HANDLE ( WINAPI * PFILE_FINDFIRST )( LPCTSTR lpcszFileSpec, FILE_FIND_DATA * pfd );
HANDLE WINAPI File_FindFirst( LPCTSTR lpcszFileSpec, FILE_FIND_DATA * pfd )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_FILESYS, FILE_FINDFIRST, 2 );
    cs.arg0 = (DWORD)lpcszFileSpec;
    return (HANDLE)CALL_SERVER( &cs, pfd );
#else

	PFILE_FINDFIRST pFindFirst;// = (PRGN_EQUAL)lpRgnAPI[RGN_EQUAL];

	CALLSTACK cs;
	HANDLE   retv = NULL;

	if( API_Enter( API_FILESYS, FILE_FINDFIRST, &pFindFirst, &cs ) )
	{
		lpcszFileSpec = MapProcessPtr( lpcszFileSpec, (LPPROCESS)cs.lpvData );
		pfd = MapProcessPtr( pfd, (LPPROCESS)cs.lpvData );

		retv = pFindFirst( lpcszFileSpec, pfd );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PFILE_FINDNEXT )( HANDLE hFind, FILE_FIND_DATA * pfd );
BOOL WINAPI File_FindNext( HANDLE hFind, FILE_FIND_DATA * pfd )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_FILESYS, FILE_FINDNEXT, 2 );
    cs.arg0 = (DWORD)hFind;
    return (DWORD)CALL_SERVER( &cs, pfd );
#else

	PFILE_FINDNEXT pFindNext;// = (PRGN_EQUAL)lpRgnAPI[RGN_EQUAL];

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_FILESYS, FILE_FINDNEXT, &pFindNext, &cs ) )
	{
		pfd = MapProcessPtr( pfd, (LPPROCESS)cs.lpvData );

		retv = pFindNext( hFind, pfd );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PFILE_FLUSHBUFFERS )( HANDLE hFile );
BOOL WINAPI File_FlushBuffers( HANDLE hFile )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API_HANDLE( API_FILESYS, FILE_FLUSHBUFFERS, 1 );
    cs.arg0 = (DWORD)hFile ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PFILE_FLUSHBUFFERS pFlushBuffers;// = (PRGN_EQUAL)lpRgnAPI[RGN_EQUAL];

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_EnterHandle( API_FILESYS, FILE_FLUSHBUFFERS, &pFlushBuffers, &cs, &hFile ) )
	{
		retv = pFlushBuffers( hFile );//HandleToPtr(hFile, OBJ_FILE) );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PFILE_GETDISKFREESPACEEX )( 
						    LPCTSTR lpcszPathName, 
                            LPDWORD lpdwFreeBytesAvailableToCaller, 
                            LPDWORD lpdwTotalNumberOfBytes, 
                            LPDWORD lpdwTotalNumberOfFreeBytes );
BOOL WINAPI File_GetDiskFreeSpaceEx( 
						    LPCTSTR lpcszPathName, 
                            LPDWORD lpdwFreeBytesAvailableToCaller, 
                            LPDWORD lpdwTotalNumberOfBytes, 
                            LPDWORD lpdwTotalNumberOfFreeBytes )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_FILESYS, FILE_GETDISKFREESPACEEX, 4 );
    cs.arg0 = (DWORD)lpcszPathName;
    return (DWORD)CALL_SERVER( &cs, lpdwFreeBytesAvailableToCaller, lpdwTotalNumberOfBytes, lpdwTotalNumberOfFreeBytes );
#else

	PFILE_GETDISKFREESPACEEX pGetDiskFreeSpaceEx;// = (PRGN_EQUAL)lpRgnAPI[RGN_EQUAL];

	CALLSTACK cs;
	BOOL   retv = FALSE;

	if( API_Enter( API_FILESYS, FILE_GETDISKFREESPACEEX, &pGetDiskFreeSpaceEx, &cs ) )
	{
		lpcszPathName = MapProcessPtr( lpcszPathName, (LPPROCESS)cs.lpvData );
		lpdwFreeBytesAvailableToCaller = MapProcessPtr( lpdwFreeBytesAvailableToCaller, (LPPROCESS)cs.lpvData );
		lpdwTotalNumberOfBytes = MapProcessPtr( lpdwTotalNumberOfBytes, (LPPROCESS)cs.lpvData );
		lpdwTotalNumberOfFreeBytes = MapProcessPtr( lpdwTotalNumberOfFreeBytes, (LPPROCESS)cs.lpvData );

		retv = pGetDiskFreeSpaceEx( lpcszPathName, lpdwFreeBytesAvailableToCaller,lpdwTotalNumberOfBytes, lpdwTotalNumberOfFreeBytes);
		API_Leave(  );
	}
	return retv;
#endif
}

typedef DWORD ( WINAPI * PFILE_GETATTRIBUTES )( LPCTSTR lpcszFileName );
DWORD WINAPI File_GetAttributes( LPCTSTR lpcszFileName )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_FILESYS, FILE_GETATTRIBUTES, 1 );
    cs.arg0 = (DWORD)lpcszFileName ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PFILE_GETATTRIBUTES pGetAttributes;// = (PRGN_EQUAL)lpRgnAPI[RGN_EQUAL];

	CALLSTACK cs;
	DWORD   retv = -1;

	if( API_Enter( API_FILESYS, FILE_GETATTRIBUTES, &pGetAttributes, &cs ) )
	{
		lpcszFileName = MapProcessPtr( lpcszFileName, (LPPROCESS)cs.lpvData );

		retv = pGetAttributes( lpcszFileName );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef DWORD ( WINAPI * PFILE_GETSIZE )( HANDLE hFile, LPDWORD pFileSizeHigh );
DWORD WINAPI File_GetSize( HANDLE hFile, LPDWORD pFileSizeHigh )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API_HANDLE( API_FILESYS, FILE_GETSIZE, 2 );
    cs.arg0 = (DWORD)hFile;
    return (DWORD)CALL_SERVER( &cs, pFileSizeHigh );
#else

	PFILE_GETSIZE pGetSize;// = (PRGN_EQUAL)lpRgnAPI[RGN_EQUAL];

	CALLSTACK cs;
	DWORD   retv = INVALID_FILE_SIZE;

	if( API_EnterHandle( API_FILESYS, FILE_GETSIZE, &pGetSize, &cs, &hFile ) )
	{
		pFileSizeHigh = MapProcessPtr( pFileSizeHigh, (LPPROCESS)cs.lpvData );

		retv = pGetSize( hFile, pFileSizeHigh );//HandleToPtr(hFile, OBJ_FILE), pFileSizeHigh );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PFILE_GETINFORMATION )( HANDLE hFile, FILE_INFORMATION * pfi );
BOOL WINAPI File_GetInformation( HANDLE hFile, FILE_INFORMATION * pfi )
{
#ifdef CALL_TRAP