// check if a file handle is for kernel32.dll
static bool kludge_isKernel32Dll(HANDLE fileHandle, std::string &kernel32Name) {
static DWORD IndxHigh, IndxLow;
static bool firstTime = true;
BY_HANDLE_FILE_INFORMATION info;
static std::string kernel32Name_;
if (firstTime) {
HANDLE kernel32H;
firstTime = false;
char sysRootDir[MAX_PATH+1];
if (GetSystemDirectory(sysRootDir, MAX_PATH) == 0)
assert(0);
kernel32Name_ = std::string(sysRootDir) + "\\kernel32.dll";
kernel32H = CreateFile(kernel32Name_.c_str(), GENERIC_READ,
FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
assert(kernel32H);
if (!GetFileInformationByHandle(kernel32H, &info)) {
printSysError(GetLastError());
assert(0);
}
IndxHigh = info.nFileIndexHigh;
IndxLow = info.nFileIndexLow;
CloseHandle(kernel32H);
}
if (!GetFileInformationByHandle(fileHandle, &info))
return false;
if (info.nFileIndexHigh==IndxHigh && info.nFileIndexLow==IndxLow) {
kernel32Name = kernel32Name_;
return true;
}
return false;
}
bool LuaProxy::Misc::isSamePath(const std::string first, const std::string second)
{
HANDLE hFileFirst = CreateFileA(first.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
if (hFileFirst == INVALID_HANDLE_VALUE) return false;
HANDLE hFileSecond = CreateFileA(second.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
if (hFileSecond == INVALID_HANDLE_VALUE) {
CloseHandle(hFileFirst);
return false;
}
BY_HANDLE_FILE_INFORMATION fInfoFirst = { 0 };
BY_HANDLE_FILE_INFORMATION fInfoSecond = { 0 };
BOOL success = GetFileInformationByHandle(hFileFirst, &fInfoFirst);
success = success && GetFileInformationByHandle(hFileSecond, &fInfoSecond);
if (!success) {
CloseHandle(hFileFirst);
CloseHandle(hFileSecond);
return false;
}
bool isSame = fInfoFirst.dwVolumeSerialNumber == fInfoSecond.dwVolumeSerialNumber &&
fInfoFirst.nFileIndexLow == fInfoSecond.nFileIndexLow &&
fInfoFirst.nFileIndexHigh == fInfoSecond.nFileIndexHigh;
CloseHandle(hFileFirst);
CloseHandle(hFileSecond);
return isSame;
}
// Code adapted from http://stackoverflow.com/questions/562701/best-way-to-determine-if-two-path-reference-to-same-file-in-c-c/562830#562830
// Determine if 2 paths point ot the same file...
bool IsSame(const WCHAR *path1, const WCHAR *path2)
{
bool isSame = false, needFallback = true;
HANDLE handle1 = CreateFile(path1, 0, 0, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
HANDLE handle2 = CreateFile(path2, 0, 0, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (handle1 != INVALID_HANDLE_VALUE && handle2 != INVALID_HANDLE_VALUE) {
BY_HANDLE_FILE_INFORMATION fi1, fi2;
if (GetFileInformationByHandle(handle1, &fi1) && GetFileInformationByHandle(handle2, &fi2)) {
isSame = fi1.dwVolumeSerialNumber == fi2.dwVolumeSerialNumber &&
fi1.nFileIndexHigh == fi2.nFileIndexHigh &&
fi1.nFileIndexLow == fi2.nFileIndexLow;
needFallback = false;
}
}
CloseHandle(handle1);
CloseHandle(handle2);
if (!needFallback)
return isSame;
ScopedMem<WCHAR> npath1(Normalize(path1));
ScopedMem<WCHAR> npath2(Normalize(path2));
// consider the files different, if their paths can't be normalized
if (!npath1 || !npath2)
return false;
return str::EqI(npath1, npath2);
}
int CheckFiles(HANDLE hFile1, HANDLE hFile2)
{
BY_HANDLE_FILE_INFORMATION info1;
BY_HANDLE_FILE_INFORMATION info2;
BOOL r1 = GetFileInformationByHandle(hFile1, &info1);
BOOL r2 = GetFileInformationByHandle(hFile2, &info2);
if (!r1 && !r2) {
return 0;
}
else if (r1 && !r2) {
return 1;
}
else if (!r1 && r2) {
return -1;
}
if (info1.dwVolumeSerialNumber != info2.dwVolumeSerialNumber) {
return info1.dwVolumeSerialNumber - info2.dwVolumeSerialNumber;
}
if (info1.nFileIndexHigh != info2.nFileIndexHigh) {
return info1.nFileIndexHigh - info2.nFileIndexHigh;
}
return info1.nFileIndexLow - info2.nFileIndexLow;
}
/* Return non-zero if F1 and F2 are 2 streams representing the same
file or pipe or device. */
int
same_stream (FILE *f1, FILE *f2)
{
HANDLE fh1 = (HANDLE)_get_osfhandle (fileno (f1));
HANDLE fh2 = (HANDLE)_get_osfhandle (fileno (f2));
/* Invalid file descriptors get treated as different streams. */
if (fh1 && fh1 != INVALID_HANDLE_VALUE
&& fh2 && fh2 != INVALID_HANDLE_VALUE)
{
if (fh1 == fh2)
return 1;
else
{
DWORD ftyp1 = GetFileType (fh1), ftyp2 = GetFileType (fh2);
if (ftyp1 != ftyp2
|| ftyp1 == FILE_TYPE_UNKNOWN || ftyp2 == FILE_TYPE_UNKNOWN)
return 0;
else if (ftyp1 == FILE_TYPE_CHAR)
{
/* For character devices, check if they both refer to a
console. This loses if both handles refer to the
null device (FIXME!), but in that case we don't care
in the context of Make. */
DWORD conmode1, conmode2;
/* Each process on Windows can have at most 1 console,
so if both handles are for the console device, they
are the same. We also compare the console mode to
distinguish between stdin and stdout/stderr. */
if (GetConsoleMode (fh1, &conmode1)
&& GetConsoleMode (fh2, &conmode2)
&& conmode1 == conmode2)
return 1;
}
else
{
/* For disk files and pipes, compare their unique
attributes. */
BY_HANDLE_FILE_INFORMATION bhfi1, bhfi2;
/* Pipes get zero in the volume serial number, but do
appear to have meaningful information in file index
attributes. We test file attributes as well, for a
good measure. */
if (GetFileInformationByHandle (fh1, &bhfi1)
&& GetFileInformationByHandle (fh2, &bhfi2))
return (bhfi1.dwVolumeSerialNumber == bhfi2.dwVolumeSerialNumber
&& bhfi1.nFileIndexLow == bhfi2.nFileIndexLow
&& bhfi1.nFileIndexHigh == bhfi2.nFileIndexHigh
&& bhfi1.dwFileAttributes == bhfi2.dwFileAttributes);
}
}
}
return 0;
}
bool
tr_sys_path_is_same (const char * path1,
const char * path2,
tr_error ** error)
{
bool ret = false;
wchar_t * wide_path1 = NULL;
wchar_t * wide_path2 = NULL;
HANDLE handle1 = INVALID_HANDLE_VALUE;
HANDLE handle2 = INVALID_HANDLE_VALUE;
BY_HANDLE_FILE_INFORMATION fi1, fi2;
assert (path1 != NULL);
assert (path2 != NULL);
wide_path1 = tr_win32_utf8_to_native (path1, -1);
if (wide_path1 == NULL)
goto fail;
wide_path2 = tr_win32_utf8_to_native (path2, -1);
if (wide_path2 == NULL)
goto fail;
handle1 = CreateFileW (wide_path1, 0, 0, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (handle1 == INVALID_HANDLE_VALUE)
goto fail;
handle2 = CreateFileW (wide_path2, 0, 0, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (handle2 == INVALID_HANDLE_VALUE)
goto fail;
/* TODO: Use GetFileInformationByHandleEx on >= Server 2012 */
if (!GetFileInformationByHandle (handle1, &fi1) || !GetFileInformationByHandle (handle2, &fi2))
goto fail;
ret = fi1.dwVolumeSerialNumber == fi2.dwVolumeSerialNumber &&
fi1.nFileIndexHigh == fi2.nFileIndexHigh &&
fi1.nFileIndexLow == fi2.nFileIndexLow;
goto cleanup;
fail:
set_system_error_if_file_found (error, GetLastError ());
cleanup:
CloseHandle (handle2);
CloseHandle (handle1);
tr_free (wide_path2);
tr_free (wide_path1);
return ret;
}
static bool GetStatByHandle(TSystemFStat& fs, FHANDLE f) {
#ifdef _win_
return GetFileInformationByHandle(f, &fs);
#else
return !fstat(f, &fs);
#endif
}
static INT_PTR CDECL fci_get_open_info( char *name, USHORT *date, USHORT *time,
USHORT *attribs, int *err, void *ptr )
{
HANDLE handle;
BY_HANDLE_FILE_INFORMATION info;
WCHAR *p, *nameW = strdupAtoW( CP_UTF8, name );
handle = CreateFileW( nameW, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, 0, NULL );
if (handle == INVALID_HANDLE_VALUE)
{
*err = GetLastError();
WINE_ERR( "failed to open %s: error %u\n", wine_dbgstr_w(nameW), *err );
cab_free( nameW );
return -1;
}
if (!GetFileInformationByHandle( handle, &info ))
{
*err = GetLastError();
CloseHandle( handle );
cab_free( nameW );
return -1;
}
FileTimeToDosDateTime( &info.ftLastWriteTime, date, time );
*attribs = info.dwFileAttributes & (_A_RDONLY | _A_HIDDEN | _A_SYSTEM | _A_ARCH);
for (p = nameW; *p; p++) if (*p >= 0x80) break;
if (*p) *attribs |= _A_NAME_IS_UTF;
cab_free( nameW );
return (INT_PTR)handle;
}
/**
* Get two values that (together with the device number), uniquely
* identify a file. Taken together these values create the windows
* equivalent of UNIX inodes. If this fails for any reason a 0 is
* returned, otherwise a 1 is returned. On failure only the st_rdev
* value is set to zero, normally the st_ino (if this is the result
* of a call to stat(), may have a sensible value).
*/
int win_get_inodes( const char *fns, ino_t *st_ino, dev_t *st_rdev )
{
HANDLE fh;
BY_HANDLE_FILE_INFORMATION info;
DWORD error;
int result = 1;
/* Open file, use FILE_SHARE_READ and FILE_SHARE_WRITE as this
* seems to be needed for win98 (but not for XP) */
fh = CreateFile( fns, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, 0, NULL );
if ( fh != INVALID_HANDLE_VALUE ) {
if ( GetFileInformationByHandle( fh, &info ) ) {
*st_ino = info.nFileIndexLow;
*st_rdev = info.nFileIndexHigh;
}
else {
*st_rdev = 0;
result = 0;
}
CloseHandle( fh );
}
else {
*st_rdev = 0;
result = 0;
}
return result;
}
__int64 FileReader::GetFileSize()
{
CAutoLockFR rLock (&m_accessLock);
if (m_hFile == INVALID_HANDLE_VALUE)
{
//LogDebug("FileReader::GetFileSize() no open file");
return -1;
}
BY_HANDLE_FILE_INFORMATION fileinfo;
//fill the structure with info regarding the file
if (GetFileInformationByHandle(m_hFile, &fileinfo))
{
//Extract the file size info
LARGE_INTEGER li;
li.LowPart = fileinfo.nFileSizeLow;
li.HighPart = fileinfo.nFileSizeHigh;
return li.QuadPart;
}
HRESULT lastErr = HRESULT_FROM_WIN32(GetLastError());
LogDebug("FileReader::GetFileSize() failed. Error 0x%x, %ws, filename = %ws", lastErr, HresultToCString(lastErr), m_pFileName);
return -1;
}
unsigned int TA_FileSize( TA_FileHandle *handle )
{
#if defined( USE_WIN32_API )
BY_HANDLE_FILE_INFORMATION bhfi;
#endif
TA_FileHandlePriv *fileHandlePriv;
unsigned int fileSize;
TA_ASSERT_RET( handle != NULL, 0 );
fileHandlePriv = (TA_FileHandlePriv *)handle;
if( fileHandlePriv->streamAccess )
{
/* Use the stream instead of the file. */
fileSize = TA_StreamSizeInByte( fileHandlePriv->stream );
}
else
{
#if defined( USE_WIN32_API )
TA_ASSERT_RET( fileHandlePriv->handle != INVALID_HANDLE_VALUE, 0 );
GetFileInformationByHandle( fileHandlePriv->handle, &bhfi );
fileSize = bhfi.nFileSizeLow;
#endif
#if defined( USE_OSLAYER )
TA_ASSERT_RET( fileHandlePriv->handle != NULL, 0 );
fileSize = get_file_size( fileHandlePriv->path );
#endif
}
return fileSize;
}
static int filefind_index_number_of_links_helper(lua_State* L, struct FileFindInfo* info) {
#if defined(_WIN32)
HANDLE handle;
BY_HANDLE_FILE_INFORMATION fileInformation;
char fullPath[MAX_PATH];
strcpy(fullPath, info->path);
strcat(fullPath, info->fd.cFileName);
handle = CreateFile(fullPath, 0, 0, NULL, OPEN_EXISTING, 0, NULL);
if (handle == INVALID_HANDLE_VALUE) {
lua_pushnumber(L, 0);
return 1;
}
if (GetFileInformationByHandle(handle, &fileInformation) == FALSE) {
CloseHandle(handle);
lua_pushnumber(L, 0);
return 1;
}
CloseHandle(handle);
lua_pushnumber(L, fileInformation.nNumberOfLinks);
#else
lua_pushnumber(L, 0);
#endif
return 1;
}
bool CRawFile::Stat( struct stat *pFileStats ) const
{
#ifdef _WIN32
BY_HANDLE_FILE_INFORMATION info;
if (!GetFileInformationByHandle( m_file, &info ))
return false;
pFileStats->st_size = info.nFileSizeLow;
pFileStats->st_dev = info.nFileIndexLow;
pFileStats->st_atime = info.ftLastAccessTime.dwLowDateTime;
pFileStats->st_ctime = info.ftCreationTime.dwLowDateTime;
pFileStats->st_mtime = info.ftLastWriteTime.dwLowDateTime;
pFileStats->st_dev = info.dwVolumeSerialNumber;
pFileStats->st_mode = 0;
pFileStats->st_nlink = (unsigned short)info.nNumberOfLinks;
pFileStats->st_rdev = 0;
pFileStats->st_gid = 0;
return true;
#elif __linux
return fstat( fileno( m_file ), pFileStats ) != 0;
#else
return false;
#endif //OS DEPENDANT CODE
}
/*************************************************************************
* IStream_fnStat
*/
static HRESULT WINAPI IStream_fnStat(IStream *iface, STATSTG* lpStat,
DWORD grfStatFlag)
{
ISHFileStream *This = impl_from_IStream(iface);
BY_HANDLE_FILE_INFORMATION fi;
TRACE("(%p,%p,%d)\n", This, lpStat, grfStatFlag);
if (!grfStatFlag)
return STG_E_INVALIDPOINTER;
memset(&fi, 0, sizeof(fi));
GetFileInformationByHandle(This->hFile, &fi);
if (grfStatFlag & STATFLAG_NONAME)
lpStat->pwcsName = NULL;
else
lpStat->pwcsName = StrDupW(This->lpszPath);
lpStat->type = This->type;
lpStat->cbSize.u.LowPart = fi.nFileSizeLow;
lpStat->cbSize.u.HighPart = fi.nFileSizeHigh;
lpStat->mtime = fi.ftLastWriteTime;
lpStat->ctime = fi.ftCreationTime;
lpStat->atime = fi.ftLastAccessTime;
lpStat->grfMode = This->dwMode;
lpStat->grfLocksSupported = 0;
memcpy(&lpStat->clsid, &IID_IStream, sizeof(CLSID));
lpStat->grfStateBits = This->grfStateBits;
lpStat->reserved = 0;
return S_OK;
}
bool GetPlatformFileInfo(PlatformFile file, PlatformFileInfo* info)
{
ThreadRestrictions::AssertIOAllowed();
if(!info)
{
return false;
}
BY_HANDLE_FILE_INFORMATION file_info;
if(GetFileInformationByHandle(file, &file_info) == 0)
{
return false;
}
LARGE_INTEGER size;
size.HighPart = file_info.nFileSizeHigh;
size.LowPart = file_info.nFileSizeLow;
info->size = size.QuadPart;
info->is_directory =
(file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
info->last_modified = base::Time::FromFileTime(file_info.ftLastWriteTime);
info->last_accessed = base::Time::FromFileTime(file_info.ftLastAccessTime);
info->creation_time = base::Time::FromFileTime(file_info.ftCreationTime);
return true;
}
/**
* stat a file and return the appropriate object
* This would better be done on an open file handle
*/
int file_metadata_t::stat(const tstring &fn,
file_metadata_t *m,
class display &ocb)
{
struct __stat64 sb;
if (::TSTAT(fn.c_str(),&sb))
{
ocb.error_filename(fn,"%s",strerror(errno));
return -1;
}
m->fileid.dev = sb.st_dev;
#ifdef _WIN32
BY_HANDLE_FILE_INFORMATION fileinfo;
HANDLE filehandle = CreateFile(fn.c_str(),
0, // desired access
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS),
NULL);
// RBF - Error check CreateFile
(void)GetFileInformationByHandle(filehandle, &fileinfo);
CloseHandle(filehandle);
m->fileid.ino = (((uint64_t)fileinfo.nFileIndexHigh)<<32) | (fileinfo.nFileIndexLow);
#else
m->fileid.ino = sb.st_ino;
#endif
m->nlink = sb.st_nlink;
m->size = sb.st_size;
m->ctime = sb.st_ctime;
m->mtime = sb.st_mtime;
m->atime = sb.st_atime;
return 0;
}
ofint32
OFFile::type( )
{
ofint32 t = 0;
#if defined(OFOPSYS_LINUX) || defined(OFOPSYS_SOLARIS) || defined(OFOPSYS_FREEBSD) || defined(OFOPSYS_DARWIN)
struct stat statbuf;
ofint32 rc = fstat( m_handle, &statbuf );
if ( rc == -1 )
t = -1;
if ( S_ISDIR(statbuf.st_mode) )
t = OFFILE_FILETYPE_DIR;
if ( S_ISREG(statbuf.st_mode) )
t = OFFILE_FILETYPE_FILE;
#elif defined(OFOPSYS_WIN32) && !defined(__CYGWIN__)
BY_HANDLE_FILE_INFORMATION fi;
GetFileInformationByHandle( m_handle, &fi );
if ( fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
t = OFFILE_FILETYPE_DIR;
if ( ( fi.dwFileAttributes & FILE_ATTRIBUTE_NORMAL) || ( fi.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN ) ||
( fi.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) )
t = OFFILE_FILETYPE_FILE;
#else
#error Undefined platform
#endif
return t;
}
int mingw_fstat(int fd, struct stat *buf)
{
HANDLE fh = (HANDLE)_get_osfhandle(fd);
BY_HANDLE_FILE_INFORMATION fdata;
if (fh == INVALID_HANDLE_VALUE) {
errno = EBADF;
return -1;
}
/* direct non-file handles to MS's fstat() */
if (GetFileType(fh) != FILE_TYPE_DISK)
return _fstati64(fd, buf);
if (GetFileInformationByHandle(fh, &fdata)) {
buf->st_ino = 0;
buf->st_gid = 0;
buf->st_uid = 0;
buf->st_nlink = 1;
buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes);
buf->st_size = fdata.nFileSizeLow |
(((off_t)fdata.nFileSizeHigh)<<32);
buf->st_dev = buf->st_rdev = 0; /* not used by Git */
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 0;
}
errno = EBADF;
return -1;
}
LONG gfile_get_length(GFile *gf)
{
BY_HANDLE_FILE_INFORMATION fi;
ASSERT(gf != NULL);
GetFileInformationByHandle((HANDLE)gf->m_hFile, &fi);
return fi.nFileSizeLow;
}
static void compute_socketname(char socketname[PATHSZ], struct stat *st)
#endif
{
#ifdef _WIN32
CHAR user[UNLEN + 1];
DWORD dwBufSize = UNLEN;
BY_HANDLE_FILE_INFORMATION info;
HANDLE hFile = CreateFile(merlin_path, FILE_READ_ATTRIBUTES, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (hFile == INVALID_HANDLE_VALUE || !GetFileInformationByHandle(hFile, &info))
failwith_perror("stat (cannot find ocamlmerlin binary)");
CloseHandle(hFile);
if (!GetUserName(user, &dwBufSize))
user[0] = '\0';
// @@DRA Need to use Windows API functions to get meaningful values for st_dev and st_ino
snprintf(eventname, PATHSZ,
"ocamlmerlin_%s_%lx_%llx",
user,
info.dwVolumeSerialNumber,
((__int64)info.nFileIndexHigh) << 32 | ((__int64)info.nFileIndexLow));
snprintf(socketname, PATHSZ,
"\\\\.\\pipe\\%s", eventname);
#else
snprintf(socketname, PATHSZ,
"ocamlmerlin_%llu_%llu_%llu.socket",
(unsigned long long)getuid(),
(unsigned long long)st->st_dev,
(unsigned long long)st->st_ino);
#endif
}
bool os_fstat(int fd, const char* path, pony_stat_t* p)
{
#if defined(PLATFORM_IS_WINDOWS)
HANDLE h = (HANDLE)_get_osfhandle(fd);
BY_HANDLE_FILE_INFORMATION fa;
if(!GetFileInformationByHandle(h, &fa))
return false;
struct __stat64 st;
if(_fstat64(fd, &st) != 0)
return false;
windows_stat(path, p, &st, fa.dwFileAttributes,
&fa.ftLastAccessTime, &fa.ftLastWriteTime, &fa.ftCreationTime);
return true;
#elif defined(PLATFORM_IS_POSIX_BASED)
(void)path;
struct stat st;
if(fstat(fd, &st) != 0)
return false;
unix_stat(p, &st);
return true;
#endif
}
void getfileinfo(void) {
OFSTRUCT lpReOpenBuff;
hfFile = (HANDLE)OpenFile(szFileName, &lpReOpenBuff, NULL);
if (hfFile == (HANDLE)HFILE_ERROR) {
err_msg(); // exit if error
exit(0);
}
GetFileInformationByHandle(hfFile, &lpFileInformation);
FileTimeToLocalFileTime(&lpFileInformation.ftLastWriteTime, &lpLastWriteLocalTime);
FileTimeToSystemTime(&lpLastWriteLocalTime, &lpLastWriteSystemTime);
GetFileTime(hfFile, &lpCreationTime, &lpLastAccessTime, &lpLastWriteTime);
FileTimeToSystemTime(&lpCreationTime, &lpSystemTime);
lpSystemTime.wYear = 2010;
SystemTimeToFileTime(&lpSystemTime, &lpCreationTime);
SetFileTime(hfFile, &lpCreationTime, &lpLastAccessTime, &lpLastWriteTime);
printf ("\n\nFile size: %d", lpFileInformation.nFileSizeLow);
printf ("\n---LastWriteTime---");
printtime(lpLastWriteSystemTime);
printf ("---FileAttributes---\n");
printattrib();
CloseHandle(hfFile);
}
static INT_PTR CDECL get_open_info(char *pszName, USHORT *pdate, USHORT *ptime,
USHORT *pattribs, int *err, void *pv)
{
BY_HANDLE_FILE_INFORMATION finfo;
FILETIME filetime;
HANDLE handle;
DWORD attrs;
BOOL res;
handle = CreateFile(pszName, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
ok(handle != INVALID_HANDLE_VALUE, "Failed to CreateFile %s\n", pszName);
res = GetFileInformationByHandle(handle, &finfo);
ok(res, "Expected GetFileInformationByHandle to succeed\n");
FileTimeToLocalFileTime(&finfo.ftLastWriteTime, &filetime);
FileTimeToDosDateTime(&filetime, pdate, ptime);
attrs = GetFileAttributes(pszName);
ok(attrs != INVALID_FILE_ATTRIBUTES, "Failed to GetFileAttributes\n");
return (INT_PTR)handle;
}
PHP_WIN32_IPC_API key_t
ftok(const char *pathname, int proj_id)
{
HANDLE fh;
struct stat st;
BY_HANDLE_FILE_INFORMATION bhfi;
key_t ret;
if (stat(pathname, &st) < 0) {
return (key_t)-1;
}
if ((fh = CreateFile(pathname, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE) {
return (key_t)-1;
}
if (!GetFileInformationByHandle(fh, &bhfi)) {
CloseHandle(fh);
return (key_t)-1;
}
ret = (key_t) ((proj_id & 0xff) << 24 | (st.st_dev & 0xff) << 16 | ((bhfi.nFileIndexLow | (__int64)bhfi.nFileIndexHigh << 32) & 0xffff));
CloseHandle(fh);
return ret;
}
value onlyWin32_getFileInformationByHandle_ml(value handle_v)
{
HANDLE handle = (HANDLE)handle_v;
BY_HANDLE_FILE_INFORMATION fileInfo;
CAMLparam0 ();
CAMLlocal1 (v);
ULARGE_INTEGER size, index;
if( !GetFileInformationByHandle(handle, &fileInfo) ){
DWORD err = GetLastError();
win32_maperr(err);
uerror("GetFileInformationByHandle", Nothing);
}
size.HighPart = fileInfo.nFileSizeHigh;
size.LowPart = fileInfo.nFileSizeLow;
index.HighPart = fileInfo.nFileIndexHigh;
index.LowPart = fileInfo.nFileIndexLow;
v = caml_alloc (8, 0);
Store_field(v,0, Val_int(fileInfo.dwFileAttributes));
Store_field(v, 1,
caml_copy_double(FileTime_to_POSIX(fileInfo.ftCreationTime)));
Store_field(v, 2,
caml_copy_double(FileTime_to_POSIX(fileInfo.ftLastAccessTime)));
Store_field(v, 3,
caml_copy_double(FileTime_to_POSIX(fileInfo.ftLastWriteTime)));
Store_field(v, 4, Val_int(fileInfo.dwVolumeSerialNumber));
Store_field(v, 5, caml_copy_int64(size.QuadPart));
Store_field(v, 6, Val_int(fileInfo.nNumberOfLinks));
Store_field(v, 7, caml_copy_int64(index.QuadPart));
CAMLreturn (v);
}
BOOL factor_vm::windows_stat(vm_char *path)
{
BY_HANDLE_FILE_INFORMATION bhfi;
HANDLE h = CreateFileW(path,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS,
NULL);
if(h == INVALID_HANDLE_VALUE)
{
// FindFirstFile is the only call that can stat c:\pagefile.sys
WIN32_FIND_DATA st;
HANDLE h;
if(INVALID_HANDLE_VALUE == (h = FindFirstFile(path, &st)))
return false;
FindClose(h);
return true;
}
BOOL ret = GetFileInformationByHandle(h, &bhfi);
CloseHandle(h);
return ret;
}
static FNFCIGETOPENINFO(cb_getopeninfo)
{
BY_HANDLE_FILE_INFORMATION bhfi;
FILETIME filetime;
HANDLE handle;
/* Need Win32 handle to get time stamps */
handle = CreateFile(pszName, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (handle == INVALID_HANDLE_VALUE)
return -1;
if (GetFileInformationByHandle(handle, &bhfi) == FALSE)
{
CloseHandle(handle);
return -1;
}
FileTimeToLocalFileTime(&bhfi.ftLastWriteTime, &filetime);
FileTimeToDosDateTime(&filetime, pdate, ptime);
*pattribs = (int)(bhfi.dwFileAttributes &
(_A_RDONLY | _A_SYSTEM | _A_HIDDEN | _A_ARCH));
CloseHandle(handle);
return _open(pszName, _O_RDONLY | _O_BINARY | O_NOINHERIT);
}
static long
#else
static long long
#endif
get_inode(struct dirent *entry, const char *dirname)
{
#ifdef __MINGW32__
char fname[PATH_MAX];
HANDLE fh;
BY_HANDLE_FILE_INFORMATION info;
sprintf(fname, "%s\\%s", dirname, entry->d_name);
fh = CreateFile(fname, 0, 0, NULL, OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (fh == INVALID_HANDLE_VALUE)
return 0;
if (GetFileInformationByHandle(fh, &info)) {
long long inode = info.nFileIndexHigh;
inode <<= 32;
inode += info.nFileIndexLow;
return inode;
}
return 0;
#else
(void) dirname; /* silence warnings */
return entry->d_ino;
#endif
}
static void
GetFileInfo(FD_t fd, int *size, char **ctime, char **mtime, char **atime)
{
#ifdef AFS_NT40_ENV
BY_HANDLE_FILE_INFORMATION fi;
if (!GetFileInformationByHandle(fd, &fi)) {
printf("GetFileInformationByHandle failed, exiting\n");
exit(1);
}
*size = (int)fi.nFileSizeLow;
*ctime = "N/A";
*mtime = NT_date(&fi.ftLastWriteTime);
*atime = NT_date(&fi.ftLastAccessTime);
#else
struct afs_stat status;
if (afs_fstat(fd, &status) == -1) {
printf("fstat failed %d\n", errno);
exit(1);
}
*size = (int)status.st_size;
*ctime = date(status.st_ctime);
*mtime = date(status.st_mtime);
*atime = date(status.st_atime);
#endif
}
axStatus axFile::lastWriteTime ( axTimeStamp & t ) {
if( ! isValid() ) { assert(false); return axStatus_Std::not_initialized; }
BY_HANDLE_FILE_INFORMATION info;
if( ! GetFileInformationByHandle( h_, &info ) ) return axStatus_Std::File_error;
t.setFILETIME( info.ftLastWriteTime );
return 0;
}