bool foundBadFile(const wchar_t* szFileName, const wchar_t* szPath) override
{
gcString strFullPath("{0}\\{1}", szPath, szFileName);
Log("Found bad file: %s", strFullPath.c_str());
return false;
}
// callback signaled from file watching threadproc that allows us to asynchronously post changes back to JS
void NodeFSEvents::Callback(uv_async_t *handle, int status)
{
NodeFSEvents *This = static_cast<NodeFSEvents*>(handle->data);
if (This->m_pChangeInfo != NULL)
{
HandleScope scope;
// initialize wrapper to call back into JS
Local<Value> callback_v = This->handle_->Get(emit_sym);
Local<Function> callback = Local<Function>::Cast(callback_v);
Handle<Value> args[3];
args[0] = change_sym;
// iterate thru each queued file watching entry
CFileNotifyChangeInfo::LPEntry lpEntry = NULL;
while ((lpEntry = This->m_pChangeInfo->Peek()) != NULL)
{
// concatenate the root search path and the file notification path
std::wstring wstrFullPath = This->m_wstrRootPath.c_str();
wstrFullPath += lpEntry->m_wstrFilename;
// normalize path separators from '\' to '/'
std::replace(wstrFullPath.begin(), wstrFullPath.end(), '\\', '/');
// convert the full pathname to utf8
int iLen = ::WideCharToMultiByte(CP_UTF8, 0, wstrFullPath.c_str(), -1, NULL, 0, NULL, NULL);
std::string strFullPath(iLen + 1, 0x00);
::WideCharToMultiByte(CP_UTF8, 0, wstrFullPath.c_str(), -1, &strFullPath[0], iLen + 1, NULL, NULL);
// map the FILE_NOTIFY_INFORMATION 'Action' to a node fs-event.c 'enum uv_fs_event' type
int iAction;
switch(lpEntry->m_dwAction)
{
case FILE_ACTION_ADDED:
case FILE_ACTION_REMOVED:
case FILE_ACTION_RENAMED_OLD_NAME:
case FILE_ACTION_RENAMED_NEW_NAME:
iAction = UV_RENAME;
break;
case FILE_ACTION_MODIFIED:
default:
iAction = UV_CHANGE;
}
// call back into JS with each change.
args[1] = String::New(strFullPath.c_str());
args[2] = Integer::New(iAction);
callback->Call(This->handle_, 3, args);
// discard the now-processed entry
This->m_pChangeInfo->Pop();
delete lpEntry;
}
}
}
bool regSetAutoStart(bool minimized) {
HKEY hKey;
TCHAR szPath[MAX_PATH];
GetModuleFileName(NULL, szPath, MAX_PATH );
bool lRet, valueExists = false;
if (RegOpenKeyExA(HKEY_CURRENT_USER, (LPCSTR)"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",0,KEY_ALL_ACCESS,&hKey) == ERROR_SUCCESS) {
if (minimized) {
CString fullPathWithMinimized;
fullPathWithMinimized += "\"";
fullPathWithMinimized += szPath;
fullPathWithMinimized += "\"";
fullPathWithMinimized += " /minimized";
CT2CA pszConvertedAnsiString (fullPathWithMinimized);
std::string strFullPathWithMinimized(pszConvertedAnsiString);
std::string exeName;
getExeNameStr(&exeName);
if(RegSetValueExA(hKey, (LPCSTR)((exeName.append(" /minimized")).c_str()), 0, REG_SZ, (BYTE *)strFullPathWithMinimized.c_str(), MAX_PATH) == ERROR_SUCCESS) {
lRet = true;
}
}
else {
CString fullPath;
fullPath += "\"";
fullPath += szPath;
fullPath += "\"";
CT2CA pszConvertedAnsiString (fullPath);
std::string strFullPath(pszConvertedAnsiString);
std::string exeName;
getExeNameStr(&exeName);
if(RegSetValueExA(hKey, (LPCSTR)(exeName.c_str()), 0, REG_SZ, (BYTE *)strFullPath.c_str(), MAX_PATH) == ERROR_SUCCESS) {
lRet = true;
}
}
RegCloseKey(hKey);
}
return lRet;
}
CString MakePath( LPCTSTR lpDir, DWORD dwLan, LPCTSTR lpFile )
{
CString strFullPath( lpDir );
#ifdef __LANG_1013
strFullPath += CLangMan::GetInstance()->GetLangData( dwLan )->szPath;
#else // __LANG_1013
switch( dwLan )
{
case LANG_KOR:
strFullPath += "Korean\\";
break;
case LANG_USA:
strFullPath += "English\\";
break;
case LANG_JAP:
strFullPath += "Japanese\\";
break;
case LANG_CHI:
strFullPath += "Chinese\\";
break;
case LANG_THA:
strFullPath += "Thailand\\";
break;
case LANG_TWN:
case LANG_HK:
strFullPath += "Taiwan\\";
break;
case LANG_VTN:
strFullPath += "Vietnam\\";
break;
case LANG_RUS:
strFullPath += "Russian\\";
break;
default:
AfxMessageBox( "unknown language setting" );
break;
}
#endif // __LANG_1013
strFullPath += lpFile;
return strFullPath;
}
void driver::load(const std::wstring &name, const std::wstring &file, const std::wstring &devfile)
{
TRACEV("[driver] [load(3)] > Entering routine.");
if(m_loaded) throw std::exception("driver already loaded", 0);
{
tstring strBuf = boost::str(tformat(_T("[driver] [load(3)] loading driver - name: [%1%], file: [%2%], devfile: [%3%]"))
% name.c_str() % file.c_str() % devfile.c_str() );
TRACEBUFI(strBuf);
}
m_name = name;
m_file = file;
m_devfile = devfile;
SC_HANDLE manager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if(!manager) throw win32_error("OpenSCManager");
SC_HANDLE service = CreateService(manager, m_name.c_str(), m_name.c_str(),
SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER, SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
m_file.c_str(), NULL, NULL, NULL, NULL, NULL);
if(!service)
{
DWORD err = 0;
TRACEERR("[driver] [load(3)]", L"driver not currently installed as service", err = GetLastError());
err = 0;
service = OpenService(manager, m_name.c_str(), SERVICE_ALL_ACCESS);
if(!service)
{
TRACEERR("[driver] [load(3)]", L"opening service", err = GetLastError());
CloseServiceHandle(manager);
throw win32_error("OpenService", err);
}
// make sure it has the same path as m_file.
DWORD bytes;
BOOL ret = QueryServiceConfig(service, NULL, 0, &bytes);
if(ret || (err = GetLastError()) != ERROR_INSUFFICIENT_BUFFER)
{
TRACEERR("[driver] [load(3)]", L"calling QueryServiceConfig", err);
CloseServiceHandle(service);
CloseServiceHandle(manager);
throw win32_error("QueryServiceConfig", err);
}
err = 0; // reset error-code, so that nobody else accidentally trips over it.
QUERY_SERVICE_CONFIG *qsc = (QUERY_SERVICE_CONFIG*)malloc(bytes);
if(!qsc)
{
TRACEERR("[driver] [load(3)]", L"allocating memory for QueryServiceConfig", err = GetLastError());
CloseServiceHandle(service);
CloseServiceHandle(manager);
throw std::bad_alloc();
}
ret = QueryServiceConfig(service, qsc, bytes, &bytes);
if(!ret)
{
TRACEERR("[driver] [load(3)]", L"second call to QueryServiceConfig", err = GetLastError());
CloseServiceHandle(service);
CloseServiceHandle(manager);
throw win32_error("QueryServiceConfig", err);
}
bool del = _wcsicmp(qsc->lpBinaryPathName, m_file.c_str()) != 0;
if (del)
{
// check for e.g. \??\C:\WINDOWS\System32\DRIVERS\ipfltdrv.sys
wchar_t * descr = _wgetenv(L"WINDIR");
if (descr)
{
wstring strFullPath(L"\\??\\");
strFullPath += descr;
strFullPath += L"\\";
strFullPath += m_file;
tstring strBuf = boost::str(tformat(_T("[driver] [load(3)] comparing against driver full-path:[%1%]")) % strFullPath );
TRACEBUFI(strBuf);
del = _wcsicmp(qsc->lpBinaryPathName, strFullPath.c_str()) != 0;
}
else
{
TRACEW("[driver] [load(3)] WINDIR environment variable not found!");
}
}
tstring strBuf = boost::str(tformat(_T("[driver] [load(3)] service name: [%1%], file name: [%2%]"))
% qsc->lpBinaryPathName % m_file.c_str() );
TRACEBUFI(strBuf);
free(qsc);
// paths don't match, remove service and recreate.
if(del)
{
TRACEW("[driver] [load(3)] paths don't match, removing and recreating driver-service");
TCHAR buf[128];
// if it's not removable, bail out.
if(!this->removable)
{
TRACEC("[driver] [load(3)] ERROR trying to remove driver-service");
CloseServiceHandle(service);
CloseServiceHandle(manager);
throw std::exception("unremovable service mismatch", 0);
}
// check if its running
SERVICE_STATUS status;
ret = QueryServiceStatus(service, &status);
if(!ret)
{
TRACEERR("[driver] [load(3)]", L"ERROR calling QueryServiceStatus", err = GetLastError());
CloseServiceHandle(service);
CloseServiceHandle(manager);
throw win32_error("QueryServiceStatus", err);
}
// and stop it if it is.
switch(status.dwCurrentState)
{
case SERVICE_STOPPED:
TRACEI("[driver] [load(3)] service state: [SERVICE_STOPPED]");
break;
case SERVICE_START_PENDING:
TRACEI("[driver] [load(3)] service state: [SERVICE_START_PENDING]");
break;
case SERVICE_STOP_PENDING:
TRACEI("[driver] [load(3)] service state: [SERVICE_STOP_PENDING]");
break;
case SERVICE_RUNNING:
TRACEI("[driver] [load(3)] service state: [SERVICE_RUNNING]");
break;
case SERVICE_CONTINUE_PENDING:
TRACEI("[driver] [load(3)] service state: [SERVICE_CONTINUE_PENDING]");
break;
case SERVICE_PAUSE_PENDING:
TRACEI("[driver] [load(3)] service state: [SERVICE_PAUSE_PENDING]");
break;
case SERVICE_PAUSED:
TRACEI("[driver] [load(3)] service state: [SERVICE_PAUSED]");
break;
default:
swprintf_s(buf, _countof(buf), L"[driver] [load(3)] * ERROR: Unknown service state: [%u]", status.dwCurrentState);
TRACEBUFE(buf);
break;
}
if(status.dwCurrentState != SERVICE_STOPPED && status.dwCurrentState != SERVICE_STOP_PENDING)
{
ret = ControlService(service, SERVICE_CONTROL_STOP, &status);
if(!ret)
{
TRACEERR("[driver] [load(3)]", L"ERROR stopping driver-service", err = GetLastError());
CloseServiceHandle(service);
CloseServiceHandle(manager);
throw win32_error("ControlService", err);
}
}
// now delete the service.
ret = DeleteService(service);
err = GetLastError();
CloseServiceHandle(service);
if(!ret && err != ERROR_SERVICE_MARKED_FOR_DELETE)
{
TRACEERR("[driver] [load(3)]", L"ERROR deleting driver-service", err);
CloseServiceHandle(manager);
throw win32_error("DeleteService", err);
}
// finally recreate it.
service = CreateService(manager, m_name.c_str(), m_name.c_str(),
SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER, SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
m_file.c_str(), NULL, NULL, NULL, NULL, NULL);
if(!service && (err = GetLastError()) == ERROR_SERVICE_MARKED_FOR_DELETE)
{
TRACEW("[driver] [load(3)] Service marked for delete; trying closing/reopening SCM");
CloseServiceHandle(manager);
Sleep(10000);
manager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (!manager)
{
TRACEERR("[driver] [load(3)]", L"ERROR while re-opening SCM", err = GetLastError());
throw win32_error("OpenSCManager 2", err);
}
service = CreateService(manager, m_name.c_str(), m_name.c_str(),
SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER, SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
m_file.c_str(), NULL, NULL, NULL, NULL, NULL);
}
if(!service)
{
TRACEERR("[driver] [load(3)]", L"ERROR re-creating driver-service", err = GetLastError());
CloseServiceHandle(manager);
throw win32_error("CreateService", err);
}
TRACEI("[driver] [load(3)] finished re-creating driver-service");
}
}
SERVICE_STATUS status;
if(QueryServiceStatus(service, &status))
{
if (status.dwCurrentState == SERVICE_RUNNING)
{
TRACES("[driver] [load(3)] Driver-service is running");
m_started = true;
}
else if (status.dwCurrentState == SERVICE_START_PENDING)
{
TRACEI("[driver] [load(3)] Driver-service is starting");
}
else
{
TRACEI("[driver] [load(3)] driver-service not running");
TCHAR buf[128];
swprintf_s(buf, _countof(buf), L"[driver] [load(3)] - service state: [%u]", status.dwCurrentState);
TRACEBUFW(buf);
}
}
CloseServiceHandle(service);
CloseServiceHandle(manager);
m_loaded = true;
TRACEV("[driver] [load(3)] < Leaving routine.");
}
CString MakePath( LPCTSTR lpszDirName, LPCTSTR lpszFileName )
{
CString strFullPath( lpszDirName );
strFullPath += lpszFileName;
return strFullPath;
}
void CDirectoryListing::RecurseFolder(const char *pzDir, GStringList *strDirs, GStringList *strFiles)
{
char chSlash = '\\';
static GString strDot("[dir] .");
static GString strDotDot("[dir] ..");
try
{
// Sample listing 2 files + 1 directory = "file1.txt*[dir] Temp*file2.txt"
GString strResults;
CDirectoryListing dir(pzDir, 2); // directories only
GStringIterator it(&dir);
while (it())
{
// pzResult will look something like "[dir] SubDir"
const char *pzResult = it++;
if (strDot.Compare(pzResult) != 0 && strDotDot.Compare(pzResult) != 0)
{
// pzDir may be "/myPath" to begin with
GString strFullPath(pzDir);
if ( strFullPath.GetAt(strFullPath.GetLength() - 1) != '\\' &&
strFullPath.GetAt(strFullPath.GetLength() - 1) != '/')
{
// pzDir will now end with a slash if it did not already.
// like "/myPath/" or "c:\myPath\"
strFullPath += chSlash;
}
// add the file name to the complete path we're building
strFullPath += &pzResult[6]; // skip the "[dir] ", add a string like "SubDir"
if(strDirs)
{
strDirs->AddLast(strFullPath);
}
// now add the final slash for a string like this "/myPath/SubDir/"
strFullPath += chSlash;
// go down into that directory now.
RecurseFolder(strFullPath, strDirs, strFiles);
}
}
if(strFiles)
{
CDirectoryListing files(pzDir, 1); // files only
GStringIterator it2(&files);
while (it2())
{
// pzDir may be "/myPath" to begin with
GString strFullPath(pzDir);
if ( strFullPath.GetAt(strFullPath.GetLength() - 1) != '\\' &&
strFullPath.GetAt(strFullPath.GetLength() - 1) != '/')
{
// strFullPath will now end with a slash like "/myPath/"
strFullPath += chSlash;
}
const char *pzFile = it2++;
strFullPath += pzFile;
strFiles->AddLast((const char *)strFullPath);
}
}
}
catch( GenericException & )
{
// ignore the directory we can't access
// rErr.GetDescription();
}
}
