/*

* Copyright (c) 2012 Adobe Systems Incorporated. All rights reserved.

*

* Permission is hereby granted, free of charge, to any person obtaining a

* copy of this software and associated documentation files (the "Software"),

* to deal in the Software without restriction, including without limitation

* the rights to use, copy, modify, merge, publish, distribute, sublicense,

* and/or sell copies of the Software, and to permit persons to whom the

* Software is furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

* DEALINGS IN THE SOFTWARE.

*

*/

#include "appshell_extensions.h"

#include "native_menu_model.h"

#include "client_handler.h"

#include <algorithm>

#include <CommDlg.h>

#include <Psapi.h>

#include <ShellAPI.h>

#include <ShlObj.h>

#include <Shlwapi.h>

#include <Shobjidl.h>

#include <stdio.h>

#include <sys/stat.h>

#include "config.h"

#define CLOSING_PROP L"CLOSING"

#define UNICODE_MINUS 0x2212

#define UNICODE_LEFT_ARROW 0x2190

#define UNICODE_DOWN_ARROW 0x2193

// Forward declarations for functions at the bottom of this file

void ConvertToNativePath(ExtensionString& filename);

void ConvertToUnixPath(ExtensionString& filename);

void RemoveTrailingSlash(ExtensionString& filename);

int ConvertErrnoCode(int errorCode, bool isReading = true);

int ConvertWinErrorCode(int errorCode, bool isReading = true);

static std::wstring GetPathToLiveBrowser();

static bool ConvertToShortPathName(std::wstring & path);

time_t FiletimeToTime(FILETIME const& ft);

// Redraw timeout variables. See the comment above ScheduleMenuRedraw for details.

const DWORD kMenuRedrawTimeout = 100;

UINT_PTR redrawTimerId = NULL;

CefRefPtr<CefBrowser> redrawBrowser;

extern HINSTANCE hInst;

extern HACCEL hAccelTable;

extern std::wstring gFilesToOpen;

// constants

#define MAX_LOADSTRING 100

///////////////////////////////////////////////////////////////////////////////

// LiveBrowserMgrWin

class LiveBrowserMgrWin

{

public:

static LiveBrowserMgrWin* GetInstance();

static void Shutdown();

bool IsChromeWindow(HWND hwnd);

bool IsAnyChromeWindowsRunning();

void CloseLiveBrowserKillTimers();

void CloseLiveBrowserFireCallback(int valToSend);

static BOOL CALLBACK EnumChromeWindowsCallback(HWND hwnd, LPARAM userParam);

static void CALLBACK CloseLiveBrowserTimerCallback( HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime);

static void CALLBACK CloseLiveBrowserAsyncCallback( HWND hwnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult );

CefRefPtr<CefProcessMessage> GetCloseCallback() { return m_closeLiveBrowserCallback; }

UINT GetCloseHeartbeatTimerId() { return m_closeLiveBrowserHeartbeatTimerId; }

UINT GetCloseTimeoutTimerId() { return m_closeLiveBrowserTimeoutTimerId; }

void SetCloseCallback(CefRefPtr<CefProcessMessage> closeLiveBrowserCallback)

{ m_closeLiveBrowserCallback = closeLiveBrowserCallback; }

void SetBrowser(CefRefPtr<CefBrowser> browser)

{ m_browser = browser; }

void SetCloseHeartbeatTimerId(UINT closeLiveBrowserHeartbeatTimerId)

{ m_closeLiveBrowserHeartbeatTimerId = closeLiveBrowserHeartbeatTimerId; }

void SetCloseTimeoutTimerId(UINT closeLiveBrowserTimeoutTimerId)

{ m_closeLiveBrowserTimeoutTimerId = closeLiveBrowserTimeoutTimerId; }

private:

// private so this class cannot be instantiated externally

LiveBrowserMgrWin();

virtual ~LiveBrowserMgrWin();

UINT m_closeLiveBrowserHeartbeatTimerId;

UINT m_closeLiveBrowserTimeoutTimerId;

CefRefPtr<CefProcessMessage> m_closeLiveBrowserCallback;

CefRefPtr<CefBrowser> m_browser;

static LiveBrowserMgrWin* s_instance;

};

LiveBrowserMgrWin::LiveBrowserMgrWin()

: m_closeLiveBrowserHeartbeatTimerId(0)

, m_closeLiveBrowserTimeoutTimerId(0)

{

}

LiveBrowserMgrWin::~LiveBrowserMgrWin()

{

}

LiveBrowserMgrWin* LiveBrowserMgrWin::GetInstance()

{

if (!s_instance)

s_instance = new LiveBrowserMgrWin();

return s_instance;

}

void LiveBrowserMgrWin::Shutdown()

{

delete s_instance;

s_instance = NULL;

}

bool LiveBrowserMgrWin::IsChromeWindow(HWND hwnd)

{

if( !hwnd ) {

return false;

}

//Find the path that opened this window

DWORD processId = 0;

::GetWindowThreadProcessId(hwnd, &processId);

HANDLE processHandle = ::OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processId);

if( !processHandle ) {

return false;

}

DWORD modulePathBufSize = MAX_UNC_PATH+1;

WCHAR modulePathBuf[MAX_UNC_PATH+1];

DWORD modulePathSize = ::GetModuleFileNameEx(processHandle, NULL, modulePathBuf, modulePathBufSize );

::CloseHandle(processHandle);

processHandle = NULL;

std::wstring modulePath(modulePathBuf, modulePathSize);

//See if this path is the same as what we want to launch

std::wstring appPath = GetPathToLiveBrowser();

if( !ConvertToShortPathName(modulePath) || !ConvertToShortPathName(appPath) ) {

return false;

}

if(0 != _wcsicmp(appPath.c_str(), modulePath.c_str()) ){

return false;

}

//looks good

return true;

}

struct EnumChromeWindowsCallbackData

{

bool closeWindow;

int numberOfFoundWindows;

};

BOOL CALLBACK LiveBrowserMgrWin::EnumChromeWindowsCallback(HWND hwnd, LPARAM userParam)

{

if( !hwnd || !s_instance) {

return FALSE;

}

EnumChromeWindowsCallbackData* cbData = reinterpret_cast<EnumChromeWindowsCallbackData*>(userParam);

if(!cbData) {

return FALSE;

}

if (!s_instance->IsChromeWindow(hwnd)) {

return TRUE;

}

cbData->numberOfFoundWindows++;

//This window belongs to the instance of the browser we're interested in, tell it to close

if( cbData->closeWindow ) {

::SendMessageCallback(hwnd, WM_CLOSE, NULL, NULL, CloseLiveBrowserAsyncCallback, NULL);

}

return TRUE;

}

bool LiveBrowserMgrWin::IsAnyChromeWindowsRunning()

{

EnumChromeWindowsCallbackData cbData = {0};

cbData.numberOfFoundWindows = 0;

cbData.closeWindow = false;

::EnumWindows(EnumChromeWindowsCallback, (LPARAM)&cbData);

return( cbData.numberOfFoundWindows != 0 );

}

void LiveBrowserMgrWin::CloseLiveBrowserKillTimers()

{

if (m_closeLiveBrowserHeartbeatTimerId) {

::KillTimer(NULL, m_closeLiveBrowserHeartbeatTimerId);

m_closeLiveBrowserHeartbeatTimerId = 0;

}

if (m_closeLiveBrowserTimeoutTimerId) {

::KillTimer(NULL, m_closeLiveBrowserTimeoutTimerId);

m_closeLiveBrowserTimeoutTimerId = 0;

}

}

void LiveBrowserMgrWin::CloseLiveBrowserFireCallback(int valToSend)

{

CefRefPtr<CefListValue> responseArgs = m_closeLiveBrowserCallback->GetArgumentList();

// kill the timers

CloseLiveBrowserKillTimers();

// Set common response args (callbackId and error)

responseArgs->SetInt(1, valToSend);

// Send response

m_browser->SendProcessMessage(PID_RENDERER, m_closeLiveBrowserCallback);

// Clear state

m_closeLiveBrowserCallback = NULL;

m_browser = NULL;

}

void CALLBACK LiveBrowserMgrWin::CloseLiveBrowserTimerCallback( HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime)

{

if( !s_instance ) {

::KillTimer(NULL, idEvent);

return;

}

int retVal = NO_ERROR;

if( s_instance->IsAnyChromeWindowsRunning() )

{

retVal = ERR_UNKNOWN;

//if this is the heartbeat timer, wait for another beat

if (idEvent == s_instance->m_closeLiveBrowserHeartbeatTimerId) {

return;

}

}

//notify back to the app

s_instance->CloseLiveBrowserFireCallback(retVal);

}

void CALLBACK LiveBrowserMgrWin::CloseLiveBrowserAsyncCallback( HWND hwnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult )

{

if( !s_instance ) {

return;

}

//If there are no more versions of chrome, then fire the callback

if( !s_instance->IsAnyChromeWindowsRunning() ) {

s_instance->CloseLiveBrowserFireCallback(NO_ERROR);

}

else if(s_instance->m_closeLiveBrowserHeartbeatTimerId == 0){

//start a heartbeat timer to see if it closes after the message returned

s_instance->m_closeLiveBrowserHeartbeatTimerId = ::SetTimer(NULL, 0, 30, CloseLiveBrowserTimerCallback);

}

}

LiveBrowserMgrWin* LiveBrowserMgrWin::s_instance = NULL;

static int CALLBACK SetInitialPathCallback(HWND hWnd, UINT uMsg, LPARAM lParam, LPARAM lpData)

{

if (BFFM_INITIALIZED == uMsg && NULL != lpData)

{

SendMessage(hWnd, BFFM_SETSELECTION, TRUE, lpData);

}

return 0;

}

static std::wstring GetPathToLiveBrowser()

{

HKEY hKey;

// First, look at the "App Paths" registry key for a "chrome.exe" entry. This only

// checks for installs for all users. If Chrome is only installed for the current user,

// we fall back to the code below.

if (ERROR_SUCCESS == RegOpenKeyEx(

HKEY_LOCAL_MACHINE,

L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\chrome.exe",

0, KEY_READ, &hKey)) {

wchar_t wpath[MAX_UNC_PATH] = {0};

DWORD length = MAX_UNC_PATH;

RegQueryValueEx(hKey, NULL, NULL, NULL, (LPBYTE)wpath, &length);

RegCloseKey(hKey);

return std::wstring(wpath);

}

// We didn't get an "App Paths" entry. This could be because Chrome was only installed for

// the current user, or because Chrome isn't installed at all.

// Look for Chrome.exe at C:\Users\{USERNAME}\AppData\Local\Google\Chrome\Application\chrome.exe

TCHAR localAppPath[MAX_UNC_PATH] = {0};

SHGetFolderPath(NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, localAppPath);

std::wstring appPath(localAppPath);

appPath += L"\\Google\\Chrome\\Application\\chrome.exe";

return appPath;

}

static bool ConvertToShortPathName(std::wstring & path)

{

DWORD shortPathBufSize = MAX_UNC_PATH+1;

WCHAR shortPathBuf[MAX_UNC_PATH+1];

DWORD finalShortPathSize = ::GetShortPathName(path.c_str(), shortPathBuf, shortPathBufSize);

if( finalShortPathSize == 0 ) {

return false;

}

path.assign(shortPathBuf, finalShortPathSize);

return true;

}

int32 OpenLiveBrowser(ExtensionString argURL, bool enableRemoteDebugging)

{

std::wstring appPath = GetPathToLiveBrowser();

std::wstring args = appPath;

if (enableRemoteDebugging) {

std::wstring profilePath(ClientApp::AppGetSupportDirectory());

profilePath += L"\\live-dev-profile";

args += L" --user-data-dir=\"";

args += profilePath;

args += L"\" --no-first-run --no-default-browser-check --allow-file-access-from-files --remote-debugging-port=9222 ";

} else {

args += L" ";

}

args += argURL;

// Args must be mutable

int argsBufSize = args.length() +1;

std::vector<WCHAR> argsBuf;

argsBuf.resize(argsBufSize);

wcscpy(&argsBuf[0], args.c_str());

STARTUPINFO si = {0};

si.cb = sizeof(si);

PROCESS_INFORMATION pi = {0};

// Launch cmd.exe and pass in the arguments

if (!CreateProcess(NULL, &argsBuf[0], NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {

return ConvertWinErrorCode(GetLastError());

}

CloseHandle(pi.hProcess);

CloseHandle(pi.hThread);

return NO_ERROR;

}

void CloseLiveBrowser(CefRefPtr<CefBrowser> browser, CefRefPtr<CefProcessMessage> response)

{

LiveBrowserMgrWin* liveBrowserMgr = LiveBrowserMgrWin::GetInstance();

if (liveBrowserMgr->GetCloseCallback() != NULL) {

// We can only handle a single async callback at a time. If there is already one that hasn't fired then

// we kill it now and get ready for the next.

liveBrowserMgr->CloseLiveBrowserFireCallback(ERR_UNKNOWN);

}

liveBrowserMgr->SetCloseCallback(response);

liveBrowserMgr->SetBrowser(browser);

EnumChromeWindowsCallbackData cbData = {0};

cbData.numberOfFoundWindows = 0;

cbData.closeWindow = true;

::EnumWindows(LiveBrowserMgrWin::EnumChromeWindowsCallback, (LPARAM)&cbData);

if (cbData.numberOfFoundWindows == 0) {

liveBrowserMgr->CloseLiveBrowserFireCallback(NO_ERROR);

} else if (liveBrowserMgr->GetCloseCallback()) {

// set a timeout for up to 10 seconds to close the browser

liveBrowserMgr->SetCloseTimeoutTimerId( ::SetTimer(NULL, 0, 10 * 1000, LiveBrowserMgrWin::CloseLiveBrowserTimerCallback) );

}

}

int32 OpenURLInDefaultBrowser(ExtensionString url)

{

DWORD result = (DWORD)ShellExecute(NULL, L"open", url.c_str(), NULL, NULL, SW_SHOWNORMAL);

// If the result > 32, the function suceeded. If the result is <= 32, it is an

// error code.

if (result <= 32)

return ConvertWinErrorCode(result);

return NO_ERROR;

}

int32 ShowOpenDialog(bool allowMultipleSelection,

bool chooseDirectory,

ExtensionString title,

ExtensionString initialDirectory,

ExtensionString fileTypes,

CefRefPtr<CefListValue>& selectedFiles)

{

wchar_t szFile[MAX_UNC_PATH];

szFile[0] = 0;

// Windows common file dialogs can handle Windows path only, not Unix path.

// ofn.lpstrInitialDir also needs Windows path on XP and not Unix path.

ConvertToNativePath(initialDirectory);

if (chooseDirectory) {

// check current OS version

OSVERSIONINFO osvi;

memset(&osvi, 0, sizeof(OSVERSIONINFO));

osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

if (GetVersionEx(&osvi) && (osvi.dwMajorVersion >= 6)) {

// for Vista or later, use the MSDN-preferred implementation of the Open File dialog in pick folders mode

IFileDialog *pfd;

if (SUCCEEDED(CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pfd)))) {

// configure the dialog to Select Folders only

DWORD dwOptions;

if (SUCCEEDED(pfd->GetOptions(&dwOptions))) {

pfd->SetOptions(dwOptions | FOS_PICKFOLDERS | FOS_DONTADDTORECENT);

IShellItem *shellItem = NULL;

if (SUCCEEDED(SHCreateItemFromParsingName(initialDirectory.c_str(), 0, IID_IShellItem, reinterpret_cast<void**>(&shellItem))))

pfd->SetFolder(shellItem);

pfd->SetTitle(title.c_str());

if (SUCCEEDED(pfd->Show(GetActiveWindow()))) {

IShellItem *psi;

if (SUCCEEDED(pfd->GetResult(&psi))) {

LPWSTR lpwszName = NULL;

if(SUCCEEDED(psi->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, (LPWSTR*)&lpwszName))) {

// Add directory path to the result

std::wstring wstrName(lpwszName);

ExtensionString pathName(wstrName);

ConvertToUnixPath(pathName);

selectedFiles->SetString(0, pathName);

::CoTaskMemFree(lpwszName);

}

psi->Release();

}

}

if (shellItem != NULL)

shellItem->Release();

}

pfd->Release();

}

} else {

// for XP, use the old-styled SHBrowseForFolder() implementation

BROWSEINFO bi = {0};

bi.hwndOwner = GetActiveWindow();

bi.lpszTitle = title.c_str();

bi.ulFlags = BIF_NEWDIALOGSTYLE | BIF_EDITBOX;

bi.lpfn = SetInitialPathCallback;

bi.lParam = (LPARAM)initialDirectory.c_str();

LPITEMIDLIST pidl = SHBrowseForFolder(&bi);

if (pidl != 0) {

if (SHGetPathFromIDList(pidl, szFile)) {

// Add directory path to the result

ExtensionString pathName(szFile);

ConvertToUnixPath(pathName);

selectedFiles->SetString(0, pathName);

}

IMalloc* pMalloc = NULL;

SHGetMalloc(&pMalloc);

if (pMalloc) {

pMalloc->Free(pidl);

pMalloc->Release();

}

}

}

} else {

OPENFILENAME ofn;

ZeroMemory(&ofn, sizeof(ofn));

ofn.hwndOwner = GetActiveWindow();

ofn.lStructSize = sizeof(ofn);

ofn.lpstrFile = szFile;

ofn.nMaxFile = MAX_UNC_PATH;

ofn.lpstrTitle = title.c_str();

// TODO (issue #65) - Use passed in file types. Note, when fileTypesStr is null, all files should be shown

/* findAndReplaceString( fileTypesStr, std::string(" "), std::string(";*."));

LPCWSTR allFilesFilter = L"All Files\0*.*\0\0";*/

ofn.lpstrFilter = L"All Files\0*.*\0Web Files\0*.js;*.css;*.htm;*.html\0\0";

ofn.lpstrInitialDir = initialDirectory.c_str();

ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR | OFN_EXPLORER;

if (allowMultipleSelection)

ofn.Flags |= OFN_ALLOWMULTISELECT;

if (GetOpenFileName(&ofn)) {

if (allowMultipleSelection) {

// Multiple selection encodes the files differently

// If multiple files are selected, the first null terminator

// signals end of directory that the files are all in

std::wstring dir(szFile);

// Check for two null terminators, which signal that only one file

// was selected

if (szFile[dir.length() + 1] == '\0') {

ExtensionString filePath(dir);

ConvertToUnixPath(filePath);

selectedFiles->SetString(0, filePath);

} else {

// Multiple files are selected

wchar_t fullPath[MAX_UNC_PATH];

for (int i = (dir.length() + 1), fileIndex = 0; ; fileIndex++) {

// Get the next file name

std::wstring file(&szFile[i]);

// Two adjacent null characters signal the end of the files

if (file.length() == 0)

break;

// The filename is relative to the directory that was specified as

// the first string

if (PathCombine(fullPath, dir.c_str(), file.c_str()) != NULL) {

ExtensionString filePath(fullPath);

ConvertToUnixPath(filePath);

selectedFiles->SetString(fileIndex, filePath);

}

// Go to the start of the next file name

i += file.length() + 1;

}

}

} else {

// If multiple files are not allowed, add the single file

std::wstring filePath(szFile);

ConvertToUnixPath(filePath);

selectedFiles->SetString(0, filePath);

}

}

}

return NO_ERROR;

}

int32 ShowSaveDialog(ExtensionString title,

ExtensionString initialDirectory,

ExtensionString proposedNewFilename,

ExtensionString& absoluteFilepath)

{

ConvertToNativePath(initialDirectory); // Windows common file dlgs require Windows-style paths

// call Windows common file-saveas dialog to prompt for a filename in a writeable location

OPENFILENAME ofn;

ZeroMemory(&ofn, sizeof(ofn));

ofn.hwndOwner = GetActiveWindow();

ofn.lStructSize = sizeof(ofn);

wchar_t szFile[MAX_UNC_PATH];

wcscpy(szFile, proposedNewFilename.c_str());

ofn.lpstrFile = szFile;

ofn.nMaxFile = MAX_UNC_PATH;

ofn.lpstrFilter = L"All Files\0*.*\0Web Files\0*.js;*.css;*.htm;*.html\0Text Files\0*.txt\0\0";

ofn.lpstrInitialDir = initialDirectory.c_str();

ofn.Flags = OFN_ENABLESIZING | OFN_NOREADONLYRETURN | OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST | OFN_EXPLORER;

if (GetSaveFileName(&ofn)) {

// return the validated filename using Unix-style paths

absoluteFilepath = ofn.lpstrFile;

ConvertToUnixPath(absoluteFilepath);

}

return NO_ERROR;

}

int32 IsNetworkDrive(ExtensionString path, bool& isRemote)

{

if (path.length() == 0) {

return ERR_INVALID_PARAMS;

}

DWORD dwAttr;

dwAttr = GetFileAttributes(path.c_str());

if (INVALID_FILE_ATTRIBUTES == dwAttr)

return ConvertWinErrorCode(GetLastError());

ExtensionString drive = path.substr(0, path.find('/') + 1);

isRemote = GetDriveType(drive.c_str()) == DRIVE_REMOTE;

return NO_ERROR;

}

int32 ReadDir(ExtensionString path, CefRefPtr<CefListValue>& directoryContents)

{

if (path.length() && path[path.length() - 1] != '/')

path += '/';

path += '*';

// Convert to native path to ensure that FindFirstFile and FindNextFile

// function correctly for all paths including paths to a network drive.

ConvertToNativePath(path);

WIN32_FIND_DATA ffd;

HANDLE hFind = FindFirstFile(path.c_str(), &ffd);

std::vector<ExtensionString> resultFiles;

std::vector<ExtensionString> resultDirs;

if (hFind != INVALID_HANDLE_VALUE) {

do {

// Ignore '.' and '..' and system files

if (!wcscmp(ffd.cFileName, L".") || !wcscmp(ffd.cFileName, L"..") ||

(ffd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM))

continue;

// Collect file and directory names separately

if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {

resultDirs.push_back(ExtensionString(ffd.cFileName));

} else {

resultFiles.push_back(ExtensionString(ffd.cFileName));

}

}

while (FindNextFile(hFind, &ffd) != 0);

FindClose(hFind);

}

else {

return ConvertWinErrorCode(GetLastError());

}

// On Windows, list directories first, then files

size_t i, total = 0;

for (i = 0; i < resultDirs.size(); i++)

directoryContents->SetString(total++, resultDirs[i]);

for (i = 0; i < resultFiles.size(); i++)

directoryContents->SetString(total++, resultFiles[i]);

return NO_ERROR;

}

int32 MakeDir(ExtensionString path, int32 mode)

{

// TODO (issue #1759): honor mode

ConvertToNativePath(path);

int err = SHCreateDirectoryEx(NULL, path.c_str(), NULL);

return ConvertWinErrorCode(err);

}

int32 Rename(ExtensionString oldName, ExtensionString newName)

{

if (!MoveFile(oldName.c_str(), newName.c_str()))

return ConvertWinErrorCode(GetLastError());

return NO_ERROR;

}

// function prototype for GetFinalPathNameByHandleW(), which is unavailable on Windows XP and earlier

typedef DWORD (WINAPI *PFNGFPNBH)(

_In_ HANDLE hFile,

_Out_ LPTSTR lpszFilePath,

_In_ DWORD cchFilePath,

_In_ DWORD dwFlags

);

int32 GetFileInfo(ExtensionString filename, uint32& modtime, bool& isDir, double& size, ExtensionString& realPath)

{

WIN32_FILE_ATTRIBUTE_DATA fad;

if (!GetFileAttributesEx(filename.c_str(), GetFileExInfoStandard, &fad)) {

return ConvertWinErrorCode(GetLastError());

}

DWORD dwAttr = fad.dwFileAttributes;

isDir = ((dwAttr & FILE_ATTRIBUTE_DIRECTORY) != 0);

modtime = FiletimeToTime(fad.ftLastWriteTime);

LARGE_INTEGER size_tmp;

size_tmp.HighPart = fad.nFileSizeHigh;

size_tmp.LowPart = fad.nFileSizeLow;

size = size_tmp.QuadPart;

realPath = L"";

if (dwAttr & FILE_ATTRIBUTE_REPARSE_POINT) {

// conditionally call GetFinalPathNameByHandleW() if it's available -- Windows Vista or later

HMODULE hDLL = ::GetModuleHandle(TEXT("kernel32.dll"));

PFNGFPNBH pfn = (hDLL != NULL) ? (PFNGFPNBH)::GetProcAddress(hDLL, "GetFinalPathNameByHandleW") : NULL;

if (pfn != NULL) {

HANDLE hFile;

hFile = ::CreateFileW(filename.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);

if (hFile != INVALID_HANDLE_VALUE) {

wchar_t pathBuffer[MAX_UNC_PATH + 1];

DWORD nChars;

nChars = (*pfn)(hFile, pathBuffer, MAX_UNC_PATH, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);

if (nChars && nChars <= MAX_UNC_PATH) {

// Path returned by GetFilePathNameByHandle starts with "\\?\". Remove from returned value.

realPath = &pathBuffer[4];

// UNC paths start with UNC. Update here, if needed.

if (realPath.find(L"UNC") == 0) {

realPath = L"\\" + ExtensionString(&pathBuffer[7]);

}

ConvertToUnixPath(realPath);

}

::CloseHandle(hFile);

}

// Note: all realPath errors are ignored. If the realPath can't be determined, it should not make the

// stat fail.

}

}

return NO_ERROR;

}

const int BOMLength = 3;

typedef enum CheckedState { CS_UNKNOWN, CS_NO, CS_YES };

typedef struct UTFValidationState {

UTFValidationState () {

data = NULL;

dataLen = 0;

utf1632 = CS_UNKNOWN;

preserveBOM = true;

}

char* data;

DWORD dataLen;

CheckedState utf1632;

bool preserveBOM;

} UTFValidationState;

bool hasBOM(UTFValidationState& validationState)

{

return ((validationState.dataLen >= BOMLength) && (validationState.data[0] == (char)0xEF) && (validationState.data[1] == (char)0xBB) && (validationState.data[2] == (char)0xBF));

}

bool hasUTF16_32(UTFValidationState& validationState)

{

if (validationState.utf1632 == CS_UNKNOWN) {

int flags = IS_TEXT_UNICODE_UNICODE_MASK|IS_TEXT_UNICODE_REVERSE_MASK;

// Check to see if buffer is UTF-16 or UTF-32 with or without a BOM

BOOL test = IsTextUnicode(validationState.data, validationState.dataLen, &flags);

validationState.utf1632 = (test ? CS_YES : CS_NO);

}

return (validationState.utf1632 == CS_YES);

}

void RemoveBOM(UTFValidationState& validationState)

{

if (!validationState.preserveBOM) {

validationState.dataLen -= BOMLength;

CopyMemory (validationState.data, validationState.data+3, validationState.dataLen);

}

}

bool GetBufferAsUTF8(UTFValidationState& validationState)

{

if (validationState.dataLen == 0) {

return true;

}

// if we know it's UTF-16 or UTF-32 then bail

if (hasUTF16_32(validationState)) {

return false;

}

// See if we can convert the data to UNICODE from UTF-8

// if the data isn't UTF-8, this will fail and the result will be 0

int outBuffSize = (validationState.dataLen + 1) * 2;

wchar_t* outBuffer = new wchar_t[outBuffSize];

int result = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, validationState.data, validationState.dataLen, outBuffer, outBuffSize);

delete []outBuffer;

if ((result > 0) && hasBOM(validationState)) {

RemoveBOM(validationState);

}

return (result > 0);

}

bool IsUTFLeadByte(char data)

{

return (((data & 0xF8) == 0xF0) || // 4 BYTE

((data & 0xF0) == 0xE0) || // 3 BYTE

((data & 0xE0) == 0xC0)); // 2 BYTE

}

// we can't validate something that's smaller than 12 bytes

const int kMinValidationLength = 12;

bool quickTestBufferForUTF8(UTFValidationState& validationState)

{

if (validationState.dataLen < kMinValidationLength) {

// we really don't know so just assume it's valid

return true;

}

// if we know it's UTF-16 or UTF-32 then bail

if (hasUTF16_32(validationState)) {

return false;

}

// If it has a UTF-8 BOM, then

// assume it's UTF8

if (hasBOM(validationState)) {

return true;

}

// find the last lead byte and truncate

// the buffer beforehand and check that to avoid

// checking a malformed data stream

for (int i = 1; i < 4; i++) {

int index = (validationState.dataLen - i);

if ((index > 0) && (IsUTFLeadByte(validationState.data[index]))){

validationState.dataLen = index;

break;

}

}

// this will check to see if the we have valid

// UTF8 data in the sample data. This should tell

// us if it's binary or not but doesn't necessarily

// tell us if the file is valid UTF8

return (GetBufferAsUTF8(validationState));

}

int32 ReadFile(ExtensionString filename, ExtensionString encoding, std::string& contents)

{

if (encoding != L"utf8")

return ERR_UNSUPPORTED_ENCODING;

DWORD dwAttr;

dwAttr = GetFileAttributes(filename.c_str());

if (INVALID_FILE_ATTRIBUTES == dwAttr)

return ConvertWinErrorCode(GetLastError());

if (dwAttr & FILE_ATTRIBUTE_DIRECTORY)

return ERR_CANT_READ;

HANDLE hFile = CreateFile(filename.c_str(), GENERIC_READ,

FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

int32 error = NO_ERROR;

if (INVALID_HANDLE_VALUE == hFile)

return ConvertWinErrorCode(GetLastError());

char* buffer = NULL;

DWORD dwFileSize = GetFileSize(hFile, NULL);

if (dwFileSize == 0) {

contents = "";

} else {

DWORD dwBytesRead;

// first just read a few bytes of the file

// to check for a binary or text format

// that we can't handle

// we just want to read enough to satisfy the

// UTF-16 or UTF-32 test with or without a BOM

// the UTF-8 test could result in a false-positive

// but we'll check again with all bits if we

// think it's UTF-8 based on just a few characters

// if we're going to read fewer bytes than our

// quick test then we skip the quick test and just

// do the full test below since it will be fewer reads

// We need a buffer that can handle UTF16 or UTF32 with or without a BOM

// but with enough that we can test for true UTF data to test against

// without reading partial character streams roughly 1000 characters

// at UTF32 should do it:

// 1000 chars + 32-bit BOM (UTF-32) = 4004 bytes

// 1001 chars without BOM (UTF-32) = 4004 bytes

// 2001 chars + 16 bit BOM (UTF-16) = 4004 bytes

// 2002 chars without BOM (UTF-16) = 4004 bytes

const DWORD quickTestSize = 4004;

static char quickTestBuffer[quickTestSize+1];

UTFValidationState validationState;

validationState.data = quickTestBuffer;

validationState.dataLen = quickTestSize;

if (dwFileSize > quickTestSize) {

ZeroMemory(quickTestBuffer, sizeof(quickTestBuffer));

if (ReadFile(hFile, quickTestBuffer, quickTestSize, &dwBytesRead, NULL)) {

if (!quickTestBufferForUTF8(validationState)) {

error = ERR_UNSUPPORTED_ENCODING;

}

else {

// reset the file pointer back to beginning

// since we're going to re-read the file wi

SetFilePointer(hFile, 0, NULL, FILE_BEGIN);

}

}

}

if (error == NO_ERROR) {

// either we did a quick test and we think it's UTF-8 or

// the file is small enough that we didn't spend the time

// to do a quick test so alloc the memory to read the entire

// file into memory and test it again...

buffer = (char*)malloc(dwFileSize);

if (buffer) {

validationState.data = buffer;

validationState.dataLen = dwFileSize;

validationState.preserveBOM = false;

if (ReadFile(hFile, buffer, dwFileSize, &dwBytesRead, NULL)) {

if (!GetBufferAsUTF8(validationState)) {

error = ERR_UNSUPPORTED_ENCODING;

} else {

contents = std::string(buffer, validationState.dataLen);

}

} else {

error = ConvertWinErrorCode(GetLastError(), false);

}

free(buffer);

}

else {

error = ERR_UNKNOWN;

}

}

}

CloseHandle(hFile);

return error;

}

int32 WriteFile(ExtensionString filename, std::string contents, ExtensionString encoding)

{

if (encoding != L"utf8")

return ERR_UNSUPPORTED_ENCODING;

HANDLE hFile = CreateFile(filename.c_str(), GENERIC_WRITE,

FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

DWORD dwBytesWritten;

int error = NO_ERROR;

if (INVALID_HANDLE_VALUE == hFile)

return ConvertWinErrorCode(GetLastError(), false);

// TODO (issue 67) - Should write to temp file and handle encoding

if (!WriteFile(hFile, contents.c_str(), contents.length(), &dwBytesWritten, NULL)) {

error = ConvertWinErrorCode(GetLastError(), false);

}

CloseHandle(hFile);

return error;

}

int32 SetPosixPermissions(ExtensionString filename, int32 mode)

{

DWORD dwAttr = GetFileAttributes(filename.c_str());

if (dwAttr == INVALID_FILE_ATTRIBUTES)

return ERR_NOT_FOUND;

if ((dwAttr & FILE_ATTRIBUTE_DIRECTORY) != 0)

return NO_ERROR;

bool write = (mode & 0200) != 0;

bool read = (mode & 0400) != 0;

int mask = (write ? _S_IWRITE : 0) | (read ? _S_IREAD : 0);

if (_wchmod(filename.c_str(), mask) == -1) {

return ConvertErrnoCode(errno);

}

return NO_ERROR;

}

int32 ShellDeleteFileOrDirectory(ExtensionString filename, bool allowUndo)

{

DWORD dwAttr = GetFileAttributes(filename.c_str());