int CFileHelper::getFileState(const char*szfilePath)
{
int nInfo = 0;
#ifdef SCUT_WIN32
WIN32_FILE_ATTRIBUTE_DATA info;
if (GetFileAttributesExA(szfilePath, GetFileExInfoStandard, &info) != 0)
{
nInfo = info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
}
else
{
nInfo = -1;
}
#else
struct stat st;
if (stat(szfilePath, &st) == 0) {
nInfo = S_ISDIR(st.st_mode);
}
else
{
nInfo = -1;
}
#endif
return nInfo;
}
bool getFileInfo(const char *path, FileInfo *fileInfo)
{
// TODO: Expand relative paths?
fileInfo->fullName = path;
#ifdef _WIN32
fileInfo->size = 0;
WIN32_FILE_ATTRIBUTE_DATA attrs;
if (GetFileAttributesExA(path, GetFileExInfoStandard, &attrs)) {
fileInfo->size = (uint64_t)attrs.nFileSizeLow | ((uint64_t)attrs.nFileSizeHigh << 32);
}
fileInfo->isDirectory = (attrs.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
fileInfo->isWritable = (attrs.dwFileAttributes & FILE_ATTRIBUTE_READONLY) == 0;
#else
struct stat64 file_info;
std::string copy(path);
stripTailDirSlashes(copy);
int result = stat64(copy.c_str(), &file_info);
if (result < 0) {
WLOG("IsDirectory: stat failed on %s", path);
return false;
}
fileInfo->isDirectory = S_ISDIR(file_info.st_mode);
fileInfo->isWritable = false;
fileInfo->size = file_info.st_size;
// HACK: approximation
if (file_info.st_mode & 0200)
fileInfo->isWritable = true;
#endif
return true;
}
bool file_utils::is_older_than(const char *pSrcFilename, const char *pDstFilename)
{
WIN32_FILE_ATTRIBUTE_DATA src_file_attribs;
const BOOL src_file_exists = GetFileAttributesExA(pSrcFilename, GetFileExInfoStandard, &src_file_attribs);
WIN32_FILE_ATTRIBUTE_DATA dst_file_attribs;
const BOOL dest_file_exists = GetFileAttributesExA(pDstFilename, GetFileExInfoStandard, &dst_file_attribs);
if ((dest_file_exists) && (src_file_exists))
{
LONG timeComp = CompareFileTime(&src_file_attribs.ftLastWriteTime, &dst_file_attribs.ftLastWriteTime);
if (timeComp < 0)
return true;
}
return false;
}
/*
==================
EGLExceptionHandler
==================
*/
static sint32 Sys_FileLength (const char *path)
{
WIN32_FILE_ATTRIBUTE_DATA fileData;
if (GetFileAttributesExA (path, GetFileExInfoStandard, &fileData))
return fileData.nFileSizeLow;
return -1;
}
inline FILETIME Win32GetLastWriteTime(char *FileName) {
FILETIME LastWriteTime = {};
WIN32_FILE_ATTRIBUTE_DATA Data;
if (GetFileAttributesExA(FileName, GetFileExInfoStandard, &Data)) {
LastWriteTime = Data.ftLastWriteTime;
}
return(LastWriteTime);
}
bool
FileSystem::getFileSize( string path_, File::Size& size_ )
{
size_ = 0;
WIN32_FILE_ATTRIBUTE_DATA data;
if( !GetFileAttributesExA( path_.c_str(), GetFileExInfoStandard, (LPVOID)&data ))
return true;
size_ = ((File::Size)data.nFileSizeHigh << 32) | data.nFileSizeLow;
return false;
}
static FILETIME Win32GetLastWriteTime( char *filename ) {
FILETIME result = { 0 };
WIN32_FILE_ATTRIBUTE_DATA data;
if ( GetFileAttributesExA( filename, GetFileExInfoStandard, &data ) ) {
result = data.ftLastWriteTime;
}
return result;
}
static __int64
file_size(LPCSTR lpcstrFileName)
{
WIN32_FILE_ATTRIBUTE_DATA fad;
if (!GetFileAttributesExA(lpcstrFileName, GetFileExInfoStandard, &fad))
return -1;
LARGE_INTEGER size;
size.HighPart = fad.nFileSizeHigh;
size.LowPart = fad.nFileSizeLow;
return size.QuadPart;
}
/*
* GetFileSize
* WinAPI-like function that gets the file size of @szPath
*/
inline LONGLONG GetFileSize(LPCTSTR szPath)
{
WIN32_FILE_ATTRIBUTE_DATA fad; LARGE_INTEGER size;
if(!GetFileAttributesExA(szPath, GetFileExInfoStandard, &fad))
return 0;
size.HighPart = fad.nFileSizeHigh;
size.LowPart = fad.nFileSizeLow;
return size.QuadPart;
}
size_t lw_file_size (const char * filename)
{
WIN32_FILE_ATTRIBUTE_DATA info;
LARGE_INTEGER size;
if (!GetFileAttributesExA (filename, GetFileExInfoStandard, &info))
return 0;
size.LowPart = info.nFileSizeLow;
size.HighPart = info.nFileSizeHigh;
return (size_t) size.QuadPart;
}
lw_i64 lw_last_modified (const char * filename)
{
WIN32_FILE_ATTRIBUTE_DATA info;
LARGE_INTEGER time;
if (!GetFileAttributesExA (filename, GetFileExInfoStandard, &info))
return 0;
time.LowPart = info.ftLastWriteTime.dwLowDateTime;
time.HighPart = info.ftLastWriteTime.dwHighDateTime;
return (time_t) ((time.QuadPart - 116444736000000000ULL) / 10000000);
}
bool file_utils::get_file_size(const char *pFilename, uint64_t &file_size)
{
file_size = 0;
WIN32_FILE_ATTRIBUTE_DATA attr;
if (0 == GetFileAttributesExA(pFilename, GetFileExInfoStandard, &attr))
return false;
if (attr.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
return false;
file_size = static_cast<uint64_t>(attr.nFileSizeLow) | (static_cast<uint64_t>(attr.nFileSizeHigh) << 32U);
return true;
}
optional<FileAttributes> GetAttributes(const char* Path)
{
WIN32_FILE_ATTRIBUTE_DATA wfad;
if (!GetFileAttributesExA(Path, GetFileExInfoStandard, &wfad))
return nullopt;
FileAttributes ret{};
ret.Attributes = wfad.dwFileAttributes;
ret.CreationTime = GetU64(wfad.ftCreationTime);
ret.LastAccessTime = GetU64(wfad.ftLastAccessTime);
ret.LastModifiedTime = GetU64(wfad.ftLastWriteTime);
ret.Size = GetU64(wfad.nFileSizeHigh, wfad.nFileSizeLow);
return ret;
}
// 得到指定文件的大小
ULONGLONG GetFileSizeA(const char* pszFileName)
{
if (NULL == pszFileName)
{
return 0;
}
WIN32_FILE_ATTRIBUTE_DATA data;
if (GetFileAttributesExA(pszFileName, GetFileExInfoStandard, &data))
{
ULONGLONG llFileSize = data.nFileSizeHigh;
llFileSize <<= sizeof(DWORD)*8; //左移 32 位
llFileSize += data.nFileSizeLow;
return llFileSize;
}
return 0;
}
static DWORD WINAPI fallbackGetFileAttributesW(LPCWSTR fname)
{
DWORD retval = 0;
const int buflen = (int)(wStrLen(fname) + 1);
char *cpstr = (char *)__PHYSFS_smallAlloc(buflen);
WideCharToMultiByte(CP_ACP, 0, fname, buflen, cpstr, buflen, NULL, NULL);
//retval = GetFileAttributesA(cpstr);
const BOOL res = GetFileAttributesExA(cpstr, GetFileExInfoStandard, &retval);
__PHYSFS_smallFree(cpstr);
if (!res)
{
return 0;
}
return(retval);
} /* fallbackGetFileAttributesW */
static int do_lstat(const char *file_name, struct stat *buf)
{
WIN32_FILE_ATTRIBUTE_DATA fdata;
if (GetFileAttributesExA(file_name, GetFileExInfoStandard, &fdata)) {
int fMode = S_IREAD;
if (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
fMode |= S_IFDIR;
else
fMode |= S_IFREG;
if (!(fdata.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
fMode |= S_IWRITE;
if (fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
fMode |= S_IFLNK;
buf->st_ino = 0;
buf->st_gid = 0;
buf->st_uid = 0;
buf->st_nlink = 1;
buf->st_mode = (mode_t)fMode;
buf->st_size = fdata.nFileSizeLow; /* Can't use nFileSizeHigh, since it's not a stat64 */
buf->st_dev = buf->st_rdev = (_getdrive() - 1);
buf->st_atime = filetime_to_time_t(&(fdata.ftLastAccessTime));
buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
return GIT_SUCCESS;
}
switch (GetLastError()) {
case ERROR_ACCESS_DENIED:
case ERROR_SHARING_VIOLATION:
case ERROR_LOCK_VIOLATION:
case ERROR_SHARING_BUFFER_EXCEEDED:
return GIT_EOSERR;
case ERROR_BUFFER_OVERFLOW:
case ERROR_NOT_ENOUGH_MEMORY:
return GIT_ENOMEM;
default:
return GIT_EINVALIDPATH;
}
}
/* We keep the do_lstat code in a separate function to avoid recursion.
* When a path ends with a slash, the stat will fail with ENOENT. In
* this case, we strip the trailing slashes and stat again.
*/
static int do_lstat(const char *file_name, struct stat *buf)
{
WIN32_FILE_ATTRIBUTE_DATA fdata;
if (GetFileAttributesExA(file_name, GetFileExInfoStandard, &fdata)) {
int fMode = S_IREAD;
if (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
fMode |= S_IFDIR;
else
fMode |= S_IFREG;
if (!(fdata.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
fMode |= S_IWRITE;
buf->st_ino = 0;
buf->st_gid = 0;
buf->st_uid = 0;
buf->st_mode = fMode;
buf->st_size = fdata.nFileSizeLow; /* Can't use nFileSizeHigh, since it's not a stat64 */
buf->st_blocks = size_to_blocks(buf->st_size);
buf->st_dev = _getdrive() - 1;
buf->st_atime = filetime_to_time_t(&(fdata.ftLastAccessTime));
buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
errno = 0;
return 0;
}
switch (GetLastError()) {
case ERROR_ACCESS_DENIED:
case ERROR_SHARING_VIOLATION:
case ERROR_LOCK_VIOLATION:
case ERROR_SHARING_BUFFER_EXCEEDED:
errno = EACCES;
break;
case ERROR_BUFFER_OVERFLOW:
errno = ENAMETOOLONG;
break;
case ERROR_NOT_ENOUGH_MEMORY:
errno = ENOMEM;
break;
default:
errno = ENOENT;
break;
}
return -1;
}
static inline int get_file_attr(const char *fname, WIN32_FILE_ATTRIBUTE_DATA *fdata)
{
if (GetFileAttributesExA(fname, GetFileExInfoStandard, fdata))
return 0;
switch (GetLastError()) {
case ERROR_ACCESS_DENIED:
case ERROR_SHARING_VIOLATION:
case ERROR_LOCK_VIOLATION:
case ERROR_SHARING_BUFFER_EXCEEDED:
return EACCES;
case ERROR_BUFFER_OVERFLOW:
return ENAMETOOLONG;
case ERROR_NOT_ENOUGH_MEMORY:
return ENOMEM;
default:
return ENOENT;
}
}
string GetFileCreationDate(const string & pFileName) {
stringstream ss;
WIN32_FILE_ATTRIBUTE_DATA wfad;
SYSTEMTIME st;
SYSTEMTIME localTime;
GetFileAttributesExA(pFileName.c_str(), GetFileExInfoStandard, &wfad);
FileTimeToSystemTime(&wfad.ftLastWriteTime, &st);
SystemTimeToTzSpecificLocalTime(nullptr, &st, &localTime);
ss << setfill('0') << setw(2) << localTime.wDay << '/' <<
setfill('0') << setw(2) << localTime.wMonth << '/' <<
setw(4) << localTime.wYear << " - " <<
setfill('0') << setw(2) << localTime.wHour << ":" <<
setfill('0') << setw(2) << localTime.wMinute << ":" <<
setfill('0') << setw(2) << localTime.wSecond;
return ss.str();
}
/*
* __wt_filesize_name --
* Return the size of a file in bytes, given a file name.
*/
int
__wt_filesize_name(
WT_SESSION_IMPL *session, const char *filename, wt_off_t *sizep)
{
WT_DECL_RET;
WIN32_FILE_ATTRIBUTE_DATA data;
char *path;
WT_RET(__wt_filename(session, filename, &path));
ret = GetFileAttributesExA(path, GetFileExInfoStandard, &data);
__wt_free(session, path);
if (ret != 0) {
*sizep =
((int64_t)data.nFileSizeHigh << 32) | data.nFileSizeLow;
return (0);
}
WT_RET_MSG(session, __wt_errno(), "%s: GetFileAttributesEx", filename);
}
size_t File::SizeBytes(void)
{
#ifdef HT_SYS_LINUX
//Need to grab size from stat struct in order to allow for
//files > 2GB in size
struct stat st;
stat(m_path.c_str(), &st);
m_size = st.st_size;
#else
WIN32_FILE_ATTRIBUTE_DATA fad;
if (!GetFileAttributesExA(m_path.c_str(), GetFileExInfoStandard, &fad))
return -1;
LARGE_INTEGER size;
size.HighPart = fad.nFileSizeHigh;
size.LowPart = fad.nFileSizeLow;
m_size = static_cast<size_t>(size.QuadPart);
#endif
return m_size;
}
internal win32_game_code Win32LoadGameCode(char *SourceDLLName, char *TempDLLName, char *LockFileName) {
win32_game_code Result = {};
WIN32_FILE_ATTRIBUTE_DATA Ignored;
if (!GetFileAttributesExA(LockFileName, GetFileExInfoStandard, &Ignored)) {
Result.DLLLastWriteTime = Win32GetLastWriteTime(SourceDLLName);
CopyFileA(SourceDLLName, TempDLLName, FALSE);
Result.GameCodeDLL = LoadLibraryA(TempDLLName);
if (Result.GameCodeDLL) {
Result.UpdateAndRender = (game_update_and_render *)GetProcAddress(Result.GameCodeDLL, "GameUpdateAndRender");
Result.GetSoundSamples = (game_get_sound_samples *)GetProcAddress(Result.GameCodeDLL, "GameGetSoundSamples");
Result.IsValid = (Result.UpdateAndRender && Result.GetSoundSamples);
}
}
if (!Result.IsValid) {
Result.UpdateAndRender = 0;
Result.GetSoundSamples = 0;
}
return(Result);
}
/*
* __wt_win_fs_size --
* Get the size of a file in bytes, by file name.
*/
int
__wt_win_fs_size(WT_FILE_SYSTEM *file_system,
WT_SESSION *wt_session, const char *name, wt_off_t *sizep)
{
DWORD windows_error;
WIN32_FILE_ATTRIBUTE_DATA data;
WT_SESSION_IMPL *session;
WT_UNUSED(file_system);
session = (WT_SESSION_IMPL *)wt_session;
if (GetFileAttributesExA(name, GetFileExInfoStandard, &data) != 0) {
*sizep =
((int64_t)data.nFileSizeHigh << 32) | data.nFileSizeLow;
return (0);
}
windows_error = __wt_getlasterror();
__wt_errx(session,
"%s: file-size: GetFileAttributesEx: %s",
name, __wt_formatmessage(session, windows_error));
return (__wt_map_windows_error(windows_error));
}
//---------------------------------------------------------------------
bool FileSystemLayer::fileExists(const Ogre::String& path) const
{
WIN32_FILE_ATTRIBUTE_DATA attr_data;
return GetFileAttributesExA(path.c_str(), GetFileExInfoStandard, &attr_data) != 0;
}
