blob: daf920d9fde2977457ad4f1e33061487517007f2 [file] [log] [blame]
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "include/core/SkTypes.h"
#if defined(SK_BUILD_FOR_WIN)
#include "include/private/base/SkNoncopyable.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkTFitsIn.h"
#include "src/base/SkLeanWindows.h"
#include "src/core/SkOSFile.h"
#include "src/core/SkStringUtils.h"
#include <io.h>
#include <new>
#include <stdio.h>
#include <sys/stat.h>
void sk_fsync(FILE* f) {
_commit(sk_fileno(f));
}
bool sk_exists(const char *path, SkFILE_Flags flags) {
int mode = 0; // existence
if (flags & kRead_SkFILE_Flag) {
mode |= 4; // read
}
if (flags & kWrite_SkFILE_Flag) {
mode |= 2; // write
}
return (0 == _access(path, mode));
}
typedef struct {
ULONGLONG fVolume;
ULONGLONG fLsbSize;
ULONGLONG fMsbSize;
} SkFILEID;
static bool sk_ino(FILE* f, SkFILEID* id) {
int fileno = _fileno((FILE*)f);
if (fileno < 0) {
return false;
}
HANDLE file = (HANDLE)_get_osfhandle(fileno);
if (INVALID_HANDLE_VALUE == file) {
return false;
}
//TODO: call GetFileInformationByHandleEx on Vista and later with FileIdInfo.
BY_HANDLE_FILE_INFORMATION info;
if (0 == GetFileInformationByHandle(file, &info)) {
return false;
}
id->fVolume = info.dwVolumeSerialNumber;
id->fLsbSize = info.nFileIndexLow + (((ULONGLONG)info.nFileIndexHigh) << 32);
id->fMsbSize = 0;
return true;
}
bool sk_fidentical(FILE* a, FILE* b) {
SkFILEID aID, bID;
return sk_ino(a, &aID) && sk_ino(b, &bID)
&& aID.fLsbSize == bID.fLsbSize
&& aID.fMsbSize == bID.fMsbSize
&& aID.fVolume == bID.fVolume;
}
class SkAutoNullKernelHandle : SkNoncopyable {
public:
SkAutoNullKernelHandle(const HANDLE handle) : fHandle(handle) { }
~SkAutoNullKernelHandle() { CloseHandle(fHandle); }
operator HANDLE() const { return fHandle; }
bool isValid() const { return SkToBool(fHandle); }
private:
HANDLE fHandle;
};
typedef SkAutoNullKernelHandle SkAutoWinMMap;
void sk_fmunmap(const void* addr, size_t) {
UnmapViewOfFile(addr);
}
void* sk_fdmmap(int fileno, size_t* length) {
HANDLE file = (HANDLE)_get_osfhandle(fileno);
if (INVALID_HANDLE_VALUE == file) {
return nullptr;
}
LARGE_INTEGER fileSize;
if (0 == GetFileSizeEx(file, &fileSize)) {
//TODO: use SK_TRACEHR(GetLastError(), "Could not get file size.") to report.
return nullptr;
}
if (!SkTFitsIn<size_t>(fileSize.QuadPart)) {
return nullptr;
}
SkAutoWinMMap mmap(CreateFileMapping(file, nullptr, PAGE_READONLY, 0, 0, nullptr));
if (!mmap.isValid()) {
//TODO: use SK_TRACEHR(GetLastError(), "Could not create file mapping.") to report.
return nullptr;
}
// Eventually call UnmapViewOfFile
void* addr = MapViewOfFile(mmap, FILE_MAP_READ, 0, 0, 0);
if (nullptr == addr) {
//TODO: use SK_TRACEHR(GetLastError(), "Could not map view of file.") to report.
return nullptr;
}
*length = static_cast<size_t>(fileSize.QuadPart);
return addr;
}
int sk_fileno(FILE* f) {
return _fileno((FILE*)f);
}
void* sk_fmmap(FILE* f, size_t* length) {
int fileno = sk_fileno(f);
if (fileno < 0) {
return nullptr;
}
return sk_fdmmap(fileno, length);
}
size_t sk_qread(FILE* file, void* buffer, size_t count, size_t offset) {
int fileno = sk_fileno(file);
HANDLE fileHandle = (HANDLE)_get_osfhandle(fileno);
if (INVALID_HANDLE_VALUE == file) {
return SIZE_MAX;
}
OVERLAPPED overlapped;
memset(&overlapped, 0, sizeof(overlapped));
ULARGE_INTEGER winOffset;
winOffset.QuadPart = offset;
overlapped.Offset = winOffset.LowPart;
overlapped.OffsetHigh = winOffset.HighPart;
if (!SkTFitsIn<DWORD>(count)) {
count = std::numeric_limits<DWORD>::max();
}
DWORD bytesRead;
if (ReadFile(fileHandle, buffer, static_cast<DWORD>(count), &bytesRead, &overlapped)) {
return bytesRead;
}
if (GetLastError() == ERROR_HANDLE_EOF) {
return 0;
}
return SIZE_MAX;
}
////////////////////////////////////////////////////////////////////////////
struct SkOSFileIterData {
SkOSFileIterData() : fHandle(0), fPath16(nullptr) { }
HANDLE fHandle;
uint16_t* fPath16;
};
static_assert(sizeof(SkOSFileIterData) <= SkOSFile::Iter::kStorageSize, "not_enough_space");
static uint16_t* concat_to_16(const char src[], const char suffix[]) {
size_t i, len = strlen(src);
size_t len2 = 3 + (suffix ? strlen(suffix) : 0);
uint16_t* dst = (uint16_t*)sk_malloc_throw((len + len2) * sizeof(uint16_t));
for (i = 0; i < len; i++) {
dst[i] = src[i];
}
if (i > 0 && dst[i-1] != '/') {
dst[i++] = '/';
}
dst[i++] = '*';
if (suffix) {
while (*suffix) {
dst[i++] = *suffix++;
}
}
dst[i] = 0;
SkASSERT(i + 1 <= len + len2);
return dst;
}
SkOSFile::Iter::Iter() { new (fSelf) SkOSFileIterData; }
SkOSFile::Iter::Iter(const char path[], const char suffix[]) {
new (fSelf) SkOSFileIterData;
this->reset(path, suffix);
}
SkOSFile::Iter::~Iter() {
SkOSFileIterData& self = *reinterpret_cast<SkOSFileIterData*>(fSelf);
sk_free(self.fPath16);
if (self.fHandle) {
::FindClose(self.fHandle);
}
self.~SkOSFileIterData();
}
void SkOSFile::Iter::reset(const char path[], const char suffix[]) {
SkOSFileIterData& self = *reinterpret_cast<SkOSFileIterData*>(fSelf);
if (self.fHandle) {
::FindClose(self.fHandle);
self.fHandle = 0;
}
if (nullptr == path) {
path = "";
}
sk_free(self.fPath16);
self.fPath16 = concat_to_16(path, suffix);
}
static bool is_magic_dir(const uint16_t dir[]) {
// return true for "." and ".."
return dir[0] == '.' && (dir[1] == 0 || (dir[1] == '.' && dir[2] == 0));
}
static bool get_the_file(HANDLE handle, SkString* name, WIN32_FIND_DATAW* dataPtr, bool getDir) {
WIN32_FIND_DATAW data;
if (nullptr == dataPtr) {
if (::FindNextFileW(handle, &data))
dataPtr = &data;
else
return false;
}
for (;;) {
if (getDir) {
if ((dataPtr->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
!is_magic_dir((uint16_t*)dataPtr->cFileName))
{
break;
}
} else {
if (!(dataPtr->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
break;
}
}
if (!::FindNextFileW(handle, dataPtr)) {
return false;
}
}
// if we get here, we've found a file/dir
if (name) {
const uint16_t* utf16name = (const uint16_t*)dataPtr->cFileName;
const uint16_t* ptr = utf16name;
while (*ptr != 0) { ++ptr; }
*name = SkStringFromUTF16(utf16name, ptr - utf16name);
}
return true;
}
bool SkOSFile::Iter::next(SkString* name, bool getDir) {
SkOSFileIterData& self = *reinterpret_cast<SkOSFileIterData*>(fSelf);
WIN32_FIND_DATAW data;
WIN32_FIND_DATAW* dataPtr = nullptr;
if (self.fHandle == 0) { // our first time
if (self.fPath16 == nullptr || *self.fPath16 == 0) { // check for no path
return false;
}
self.fHandle = ::FindFirstFileW((LPCWSTR)self.fPath16, &data);
if (self.fHandle != 0 && self.fHandle != (HANDLE)~0) {
dataPtr = &data;
}
}
return self.fHandle != (HANDLE)~0 && get_the_file(self.fHandle, name, dataPtr, getDir);
}
#endif//defined(SK_BUILD_FOR_WIN)