//-----------------------------------------------------------------------------
static void load_paths_to_exclude(LPCTSTR path) {
//-----------------------------------------------------------------------------
FILE * stream_p;
wchar_t *get_result;
size_t line_len;
struct exclude_entry **link_p;
struct exclude_entry * next_p;
if (_wfopen_s(&stream_p, path, L"r, ccs=UTF-8")) {
_wfopen_s(&error_file, error_path, L"w");
_wcserror_s(error_buffer, sizeof error_buffer/sizeof(wchar_t), errno);
fwprintf(
error_file,
L"_wfopen(%s) failed: (%d) %s\n",
path,
errno,
error_buffer
);
fclose(error_file);
ExitProcess(2);
}
link_p = &exclude_entry_list_p;
while (1) {
// create an exclude entry
next_p = (struct exclude_entry *) HeapAlloc(
GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct exclude_entry)
);
if (next_p == NULL){
report_error(L"HeapAlloc failed to allocate memory", GetLastError());
ExitProcess(203);
}
// read in the path to watch from config.txt
get_result = \
fgetws(full_file_name, ARRAYSIZE(full_file_name), stream_p);
if (NULL == get_result) {
if (0 == ferror(stream_p)) {
HeapFree(GetProcessHeap(), 0, next_p);
break;
}
_wfopen_s(&error_file, error_path, L"w");
_wcserror_s(
error_buffer, sizeof error_buffer/sizeof(wchar_t) , errno
);
fwprintf(
error_file,
L"fgetws(%s) failed: (%d) %s\n",
path,
errno,
error_buffer
);
fclose(error_file);
ExitProcess(2);
}
// clean out the newline, if there is one
line_len = wcslen(full_file_name);
if (line_len && full_file_name[line_len-1] == L'\n'){
full_file_name[line_len-1] = L'\0';
line_len--;
}
if (full_file_name[0] == L'\0')
continue;
next_p->dir_path_len = line_len;
next_p->dir_path = (wchar_t *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
(line_len + 1) * sizeof(wchar_t));
if (next_p->dir_path == NULL){
report_error(L"HeapAlloc failed to allocate memory", GetLastError());
ExitProcess(204);
}
wcsncpy_s(next_p->dir_path, line_len+1, full_file_name, line_len);
// add this entry to the list
*link_p = next_p;
// point to the new entry's next pointer
link_p = &(*link_p)->next_p;
} // while(1)
fclose(stream_p);
} // load_paths_to_exclude
HRESULT CContextPlugin::WriteContextInformation( HANDLE hFile, IWMSContext *pContext )
{
HRESULT hr = S_OK;
ContextNameHint *pContextHintValues = NULL;
DWORD nValue = 0;
WMS_CONTEXT_TYPE wmsContextType = WMS_UNKNOWN_CONTEXT_TYPE;
WCHAR wstrBuffer[MAX_PATH];
DWORD cbWritten = 0;
DWORD dwRet = 0;
if( NULL == pContext )
{
// There is no Context, nothing to write
return( hr );
}
hr = pContext->GetContextType( &wmsContextType );
if( FAILED( hr ) )
{
return( hr );
}
ZeroMemory( wstrBuffer, MAX_PATH * sizeof( WCHAR ) );
switch( wmsContextType )
{
case WMS_USER_CONTEXT_TYPE:
// Create a header for this context type
wcsncpy_s( wstrBuffer,MAX_PATH, CONTEXT_SAMPLE_USER_CONTEXT_HEADER, MAX_PATH );
pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_UserContextHintValues);
break;
case WMS_PRESENTATION_CONTEXT_TYPE:
// Create a header for this context type
wcsncpy_s( wstrBuffer, MAX_PATH,CONTEXT_SAMPLE_PRESENTATION_CONTEXT_HEADER, MAX_PATH );
pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_PresentationContextHintValues);
break;
case WMS_COMMAND_REQUEST_CONTEXT_TYPE:
// Create a header for this context type
wcsncpy_s( wstrBuffer,MAX_PATH, CONTEXT_SAMPLE_COMMAND_REQUEST_CONTEXT_HEADER, MAX_PATH );
pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_CommandContextHintValues);
break;
case WMS_COMMAND_RESPONSE_CONTEXT_TYPE:
// Create a header for this context type
wcsncpy_s( wstrBuffer,MAX_PATH, CONTEXT_SAMPLE_COMMAND_RESPONSE_CONTEXT_HEADER, MAX_PATH );
pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_CommandContextHintValues);
break;
}
if( !::WriteFile( hFile, (LPVOID) wstrBuffer, DWORD(wcslen( wstrBuffer ) * sizeof( WCHAR )), &cbWritten, NULL ) )
{
dwRet = GetLastError();
hr = HRESULT_FROM_WIN32( dwRet );
// Failed to write the header should we still continue
// No!
return( hr );
}
if( NULL == pContextHintValues )
{
return( E_UNEXPECTED );
}
// Now we loop until -1 and Write the data
while( ( NULL != pContextHintValues[nValue].wstrContextName ) && ( -1 != pContextHintValues[nValue].lContextHint ) )
{
VARIANT varValue;
VariantInit( &varValue );
ZeroMemory( wstrBuffer, MAX_PATH * sizeof( WCHAR ) );
hr = pContext->GetValue( pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, &varValue, 0 );
if( SUCCEEDED( hr ) )
{
// Write string with data information
switch( V_VT( &varValue ) )
{
case VT_BSTR:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_BSTR_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_BSTR( &varValue ) );
break;
case VT_I4:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_I4_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_I4( &varValue ), V_I4( &varValue ) );
break;
case VT_UI8:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_UI8_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_UI8( &varValue ) );
break;
case VT_CY:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_CY_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_CY( &varValue ) );
break;
case VT_DATE:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_DATE_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_DATE( &varValue ) );
break;
case VT_DECIMAL:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_DECIMAL_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_DECIMAL( &varValue ) );
break;
case VT_UNKNOWN:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_UNKNOWN_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_UNKNOWN( &varValue ) );
break;
case VT_DISPATCH:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_DISPATCH_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_DISPATCH( &varValue ) );
break;
default:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_ARRAY_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_ARRAY( &varValue ) );
break;
}
if( !::WriteFile( hFile, (LPVOID) wstrBuffer, DWORD(wcslen( wstrBuffer ) * sizeof( WCHAR )), &cbWritten, NULL ) )
{
dwRet = GetLastError();
hr = HRESULT_FROM_WIN32( dwRet );
}
}
else
{
// Value probably didn't exist for this event, don't worry about it
// good place to put breakpoint
hr = S_OK;
}
// It doesn't hurt to do a VariantClear on an Empty Variant, this way we won't leak anything.
VariantClear( &varValue );
nValue ++;
}
return( hr );
}
void CShellUpdater::UpdateShell()
{
// Tell the shell extension to purge its cache
CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Setting cache invalidation event %I64u\n", GetTickCount64());
SetEvent(m_hInvalidationEvent);
// We use the SVN 'notify' call-back to add items to the list
// Because this might call-back more than once per file (for example, when committing)
// it's possible that there may be duplicates in the list.
// There's no point asking the shell to do more than it has to, so we remove the duplicates before
// passing the list on
m_pathsForUpdating.RemoveDuplicates();
// if we use the external cache, we tell the cache directly that something
// has changed, without the detour via the shell.
CAutoFile hPipe = CreateFile(
GetCacheCommandPipeName(), // pipe name
GENERIC_READ | // read and write access
GENERIC_WRITE,
0, // no sharing
nullptr, // default security attributes
OPEN_EXISTING, // opens existing pipe
FILE_FLAG_OVERLAPPED, // default attributes
nullptr); // no template file
if (!hPipe)
return;
// The pipe connected; change to message-read mode.
DWORD dwMode = PIPE_READMODE_MESSAGE;
if (!SetNamedPipeHandleState(
hPipe, // pipe handle
&dwMode, // new pipe mode
nullptr, // don't set maximum bytes
nullptr)) // don't set maximum time
{
CTraceToOutputDebugString::Instance()(__FUNCTION__ ": SetNamedPipeHandleState failed");
return;
}
CTGitPath path;
for (int nPath = 0; nPath < m_pathsForUpdating.GetCount(); ++nPath)
{
path.SetFromWin(g_Git.CombinePath(m_pathsForUpdating[nPath]));
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": Cache Item Update for %s (%I64u)\n", (LPCTSTR)path.GetWinPathString(), GetTickCount64());
if (!path.IsDirectory())
{
// send notifications to the shell for changed files - folders are updated by the cache itself.
SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH | SHCNF_FLUSHNOWAIT, path.GetWinPath(), nullptr);
}
DWORD cbWritten;
TGITCacheCommand cmd;
cmd.command = TGITCACHECOMMAND_CRAWL;
wcsncpy_s(cmd.path, path.GetDirectory().GetWinPath(), _countof(cmd.path) - 1);
BOOL fSuccess = WriteFile(
hPipe, // handle to pipe
&cmd, // buffer to write from
sizeof(cmd), // number of bytes to write
&cbWritten, // number of bytes written
nullptr); // not overlapped I/O
if (!fSuccess || sizeof(cmd) != cbWritten)
{
DisconnectNamedPipe(hPipe);
return;
}
}
// now tell the cache we don't need it's command thread anymore
DWORD cbWritten;
TGITCacheCommand cmd;
cmd.command = TGITCACHECOMMAND_END;
WriteFile(
hPipe, // handle to pipe
&cmd, // buffer to write from
sizeof(cmd), // number of bytes to write
&cbWritten, // number of bytes written
nullptr); // not overlapped I/O
DisconnectNamedPipe(hPipe);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Sends WMI command to target after logging on.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
DWORD startWMICommand(char* command, char* target, char* username, char* password)
{
HRESULT hres;
IWbemLocator *pLoc = NULL;
IWbemServices *pSvc = NULL;
COAUTHIDENTITY *userAcct = NULL ;
COAUTHIDENTITY authIdent;
char* serverWMIA;
PWCHAR serverWMIW;
PWCHAR usernameW;
PWCHAR commandW;
PWCHAR passwordW;
WCHAR pszDomain[CREDUI_MAX_USERNAME_LENGTH+1];
WCHAR pszUserName[CREDUI_MAX_USERNAME_LENGTH+1];
PWCHAR slash;
int len = 0;
// WCHAR
len = strlen(target)+12;
serverWMIA = (char*)malloc(sizeof(char)*(len));
strcpy_s(serverWMIA, len, target);
strcat_s(serverWMIA, len, "\\ROOT\\CIMV2");
len = MultiByteToWideChar(CP_ACP,0,serverWMIA,-1,NULL,0);
serverWMIW = (PWCHAR)malloc(sizeof(WCHAR)*len);
MultiByteToWideChar(CP_ACP,0,serverWMIA,-1,serverWMIW,len);
free(serverWMIA);
len = MultiByteToWideChar(CP_ACP,0,username,-1,NULL,0);
usernameW = (PWCHAR)malloc(sizeof(WCHAR)*len);
MultiByteToWideChar(CP_ACP,0,username,-1,usernameW,len);
len = MultiByteToWideChar(CP_ACP,0,password,-1,NULL,0);
passwordW = (PWCHAR)malloc(sizeof(WCHAR)*len);
MultiByteToWideChar(CP_ACP,0,password,-1,passwordW,len);
len = MultiByteToWideChar(CP_ACP,0,command,-1,NULL,0);
commandW = (PWCHAR)malloc(sizeof(WCHAR)*len);
MultiByteToWideChar(CP_ACP,0,command,-1,commandW,len);
hres = CoInitializeEx(0, COINIT_MULTITHREADED);
if(hres<0)
{
free(usernameW);
free(passwordW);
free(commandW);
free(serverWMIA);
free(serverWMIW);
return -1;
}
hres = CoInitializeSecurity(NULL,-1,NULL,NULL,RPC_C_AUTHN_LEVEL_DEFAULT,RPC_C_IMP_LEVEL_IDENTIFY,NULL,EOAC_NONE,NULL);
if(hres<0)
{
free(usernameW);
free(passwordW);
free(commandW);
free(serverWMIA);
free(serverWMIW);
CoUninitialize();
return -1;
}
hres = CoCreateInstance(CLSID_WbemLocator,0,CLSCTX_INPROC_SERVER,IID_IWbemLocator, (LPVOID *) &pLoc);
if(hres<0)
{
free(usernameW);
free(passwordW);
free(commandW);
free(serverWMIA);
free(serverWMIW);
CoUninitialize();
return -1;
}
//WMI connection
hres = pLoc->ConnectServer(_bstr_t(serverWMIW),_bstr_t(usernameW),_bstr_t(passwordW),NULL,NULL,NULL,NULL,&pSvc);
if(hres<0)
{
free(usernameW);
free(passwordW);
free(commandW);
free(serverWMIA);
free(serverWMIW);
pLoc->Release();
CoUninitialize();
return -1;
}
//Set ProxyBlanket options
memset(&authIdent, 0, sizeof(COAUTHIDENTITY));
authIdent.PasswordLength = wcslen (passwordW);
authIdent.Password = (USHORT*)passwordW;
slash = wcschr (usernameW, L'\\');
if(slash == NULL)
{
free(usernameW);
free(passwordW);
free(commandW);
free(serverWMIA);
free(serverWMIW);
pSvc->Release();
pLoc->Release();
CoUninitialize();
return -1;
}
wcscpy_s(pszUserName,CREDUI_MAX_USERNAME_LENGTH+1, slash+1);
authIdent.User = (USHORT*)pszUserName;
authIdent.UserLength = wcslen(pszUserName);
wcsncpy_s(pszDomain, CREDUI_MAX_USERNAME_LENGTH+1, usernameW, slash - usernameW);
authIdent.Domain = (USHORT*)pszDomain;
authIdent.DomainLength = slash - usernameW;
authIdent.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
userAcct = &authIdent;
//Set the ProxyBlanket
hres = CoSetProxyBlanket(pSvc,RPC_C_AUTHN_DEFAULT,RPC_C_AUTHZ_DEFAULT,COLE_DEFAULT_PRINCIPAL,RPC_C_AUTHN_LEVEL_PKT_PRIVACY,RPC_C_IMP_LEVEL_IMPERSONATE,userAcct,EOAC_NONE);
if(hres<0)
{
free(usernameW);
free(passwordW);
free(commandW);
free(serverWMIA);
free(serverWMIW);
pSvc->Release();
pLoc->Release();
CoUninitialize();
return -1;
}
BSTR MethodName = SysAllocString(L"Create");
BSTR ClassName = SysAllocString(L"Win32_Process");
IWbemClassObject* pClass = NULL;
hres = pSvc->GetObject(ClassName, 0, NULL, &pClass, NULL);
IWbemClassObject* pInParamsDefinition = NULL;
hres = pClass->GetMethod(MethodName, 0,
&pInParamsDefinition, NULL);
IWbemClassObject* pClassInstance = NULL;
hres = pInParamsDefinition->SpawnInstance(0, &pClassInstance);
// Create the values for the "in" parameters
VARIANT varCommand;
varCommand.vt = VT_BSTR;
varCommand.bstrVal = BSTR(commandW);
// Store the value for the "in" parameters
hres = pClassInstance->Put(L"CommandLine", 0, &varCommand, 0);
// Execute Method
IWbemClassObject* pOutParams = NULL;
hres = pSvc->ExecMethod(ClassName, MethodName, 0,
NULL, pClassInstance, &pOutParams, NULL);
if (FAILED(hres))
{
free(usernameW);
free(passwordW);
free(commandW);
free(serverWMIA);
free(serverWMIW);
VariantClear(&varCommand);
SysFreeString(ClassName);
SysFreeString(MethodName);
pClass->Release();
pInParamsDefinition->Release();
pOutParams->Release();
pSvc->Release();
pLoc->Release();
CoUninitialize();
return -1;
}
free(usernameW);
free(passwordW);
free(commandW);
free(serverWMIA);
free(serverWMIW);
SecureZeroMemory(pszUserName, sizeof(pszUserName));
SecureZeroMemory(pszDomain, sizeof(pszDomain));
VariantClear(&varCommand);
SysFreeString(ClassName);
SysFreeString(MethodName);
pClass->Release();
pInParamsDefinition->Release();
pOutParams->Release();
pSvc->Release();
pLoc->Release();
CoUninitialize();
return 0;
}
Callstack::AddressDetails Win32CallstackResolver::GetAddr(DWORD64 addr)
{
AddrInfo info;
info.lineNum = 0;
memset(info.fileName, 0, sizeof(info.fileName));
memset(info.fileName, 0, sizeof(info.funcName));
wcsncpy_s(info.fileName, L"Unknown", 126);
wsprintfW(info.funcName, L"0x%08I64x", addr);
for(size_t i = 0; i < modules.size(); i++)
{
DWORD64 base = modules[i].base;
DWORD size = modules[i].size;
if(addr > base && addr < base + size)
{
if(modules[i].moduleId != 0)
info = DIA2::GetAddr(modules[i].moduleId, addr);
// if we didn't get a filename, default to the module name
if(modules[i].moduleId == 0 || info.fileName[0] == 0)
wcsncpy_s(info.fileName, modules[i].name.c_str(), 126);
if(modules[i].moduleId == 0 || info.funcName[0] == 0)
{
// if we didn't get a function name, at least indicate
// the module it came from, and an offset
wchar_t *baseName = info.fileName;
wchar_t *c = wcsrchr(baseName, '\\');
if(c)
baseName = c + 1;
c = wcsrchr(baseName, '/');
if(c)
baseName = c + 1;
wsprintfW(info.funcName, L"%s+0x%08I64x", baseName, addr - base);
c = wcsstr(info.funcName, L"pdb");
if(c)
{
if(i == 0)
{
c[0] = 'e';
c[1] = 'x';
c[2] = 'e';
}
else
{
c[0] = 'd';
c[1] = 'l';
c[2] = 'l';
}
}
}
break;
}
}
Callstack::AddressDetails ret;
ret.filename = StringFormat::Wide2UTF8(wstring(info.fileName));
ret.function = StringFormat::Wide2UTF8(wstring(info.funcName));
ret.line = info.lineNum;
return ret;
}
BOOL CALLBACK ImageHandler::MonitorEnumProcWin8(HMONITOR hMonitor, HDC /*hdcMonitor*/, LPRECT lprcMonitor, LPARAM lpData)
{
MONITORINFOEX miex;
miex.cbSize = sizeof(miex);
::GetMonitorInfo(hMonitor, &miex);
DISPLAY_DEVICE dd;
dd.cb = sizeof(dd);
::EnumDisplayDevices(miex.szDevice, 0, &dd, EDD_GET_DEVICE_INTERFACE_NAME);
#if 0
TRACE(L"name %s String %s DeviceID %s Key %s StateFlags %lu\n",
dd.DeviceName,
dd.DeviceString,
dd.DeviceID,
dd.DeviceKey,
dd.StateFlags);
#endif
wchar_t szTranscodedImage [_MAX_PATH] = L"";
TRACE(
L"searching for %s ('%s') ...\n",
miex.szDevice,
dd.DeviceID);
try
{
DWORD dwTranscodedImageCount = 0;
DWORD dwType;
DWORD dwValueSize;
LSTATUS rc;
HKEY hkey;
rc = ::RegOpenKeyEx(
HKEY_CURRENT_USER,
L"Control Panel\\Desktop",
0,
KEY_READ,
&hkey);
if( rc != ERROR_SUCCESS )
Win32Exception::Throw("RegOpenKeyEx", rc);
unique_ptr<HKEY__, RegCloseKeyHelper>hkeyPtr(hkey);
rc = ::RegQueryValueEx(
hkeyPtr.get(),
L"TranscodedImageCount",
nullptr,
&dwType,
reinterpret_cast<LPBYTE>(&dwTranscodedImageCount),
&(dwValueSize = static_cast<DWORD>(sizeof(dwTranscodedImageCount))));
if( rc != ERROR_SUCCESS )
Win32Exception::Throw("RegQueryValueEx", rc);
for(DWORD i = 0; i < dwTranscodedImageCount; ++i)
{
wchar_t szValueName [32];
_snwprintf_s(
szValueName, ARRAYSIZE(szValueName),
_TRUNCATE,
L"TranscodedImageCache_%03lu",
i);
BYTE binTranscodedImageCache [0x320];
rc = ::RegQueryValueEx(
hkeyPtr.get(),
szValueName,
nullptr,
&dwType,
binTranscodedImageCache,
&(dwValueSize = static_cast<DWORD>(sizeof(binTranscodedImageCache))));
if( rc != ERROR_SUCCESS )
Win32Exception::Throw("RegQueryValueEx", rc);
TRACE(
L"\twallpaper picture on ('%s') is '%s'\n",
reinterpret_cast<wchar_t*>(binTranscodedImageCache + 0x220),
reinterpret_cast<wchar_t*>(binTranscodedImageCache + 0x18));
wchar_t* szDeviceID1 = dd.DeviceID;
wchar_t* szDeviceID2 = reinterpret_cast<wchar_t*>(binTranscodedImageCache + 0x220);
// when monitor device id is "Default_Monitor"
// \\?\DISPLAY#Default_Monitor#...
// there is no device id in TranscodedImageCache_xxx file
if( ( *szDeviceID2 == 0 &&
wcsncmp(szDeviceID1, L"\\\\?\\DISPLAY#Default_Monitor#", 28) == 0 ) ||
wcsncmp(szDeviceID1, szDeviceID2, 128) == 0 )
{
wcsncpy_s(
szTranscodedImage, _MAX_PATH,
reinterpret_cast<wchar_t*>(binTranscodedImageCache + 0x18),
_TRUNCATE);
break;
}
}
}
catch(Win32Exception&)
{
}
MonitorEnumData* pEnumData = reinterpret_cast<MonitorEnumData*>(lpData);
std::shared_ptr<BackgroundImage> bkImage;
if( szTranscodedImage[0] )
{
TRACE(
L"wallpaper picture on %s ('%s') is '%s'\n",
miex.szDevice,
dd.DeviceID,
szTranscodedImage);
bkImage.reset(new BackgroundImage (pEnumData->bkImage->imageData));
bkImage->imageData.strFilename = szTranscodedImage;
bkImage->bWallpaper = true;
ImageHandler::LoadImageW(bkImage);
}
else
{
bkImage = pEnumData->bkImage;
}
CRect rectMonitor(lprcMonitor);
// create template image
CDC dcTemplate;
CBitmap bmpTemplate;
dcTemplate.CreateCompatibleDC(NULL);
DWORD dwNewWidth = rectMonitor.Width();
DWORD dwNewHeight = rectMonitor.Height();
ImageHandler::PaintRelativeImage(pEnumData->dcTemplate, bmpTemplate, bkImage, dwNewWidth, dwNewHeight);
dcTemplate.SelectBitmap(bmpTemplate);
ImageHandler::PaintTemplateImage(
dcTemplate,
rectMonitor.left - ::GetSystemMetrics(SM_XVIRTUALSCREEN),
rectMonitor.top - ::GetSystemMetrics(SM_YVIRTUALSCREEN),
dwNewWidth,
dwNewHeight,
rectMonitor.Width(),
rectMonitor.Height(),
pEnumData->bkImage);
return TRUE;
}
bool SendCacheCommand(BYTE command, const WCHAR * path /* = NULL */)
{
int retrycount = 2;
CAutoFile hPipe;
do
{
hPipe = CreateFile(
GetCacheCommandPipeName(), // pipe name
GENERIC_READ | // read and write access
GENERIC_WRITE,
0, // no sharing
NULL, // default security attributes
OPEN_EXISTING, // opens existing pipe
FILE_FLAG_OVERLAPPED, // default attributes
NULL); // no template file
retrycount--;
if (!hPipe)
Sleep(10);
} while ((!hPipe) && (retrycount));
if (!hPipe)
{
CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Could not connect to pipe\n");
return false;
}
// The pipe connected; change to message-read mode.
DWORD dwMode = PIPE_READMODE_MESSAGE;
if (SetNamedPipeHandleState(
hPipe, // pipe handle
&dwMode, // new pipe mode
NULL, // don't set maximum bytes
NULL)) // don't set maximum time
{
DWORD cbWritten;
TSVNCacheCommand cmd;
SecureZeroMemory(&cmd, sizeof(TSVNCacheCommand));
cmd.command = command;
if (path)
wcsncpy_s(cmd.path, path, _TRUNCATE);
retrycount = 2;
BOOL fSuccess = FALSE;
do
{
fSuccess = WriteFile(
hPipe, // handle to pipe
&cmd, // buffer to write from
sizeof(cmd), // number of bytes to write
&cbWritten, // number of bytes written
NULL); // not overlapped I/O
retrycount--;
if (! fSuccess || sizeof(cmd) != cbWritten)
Sleep(10);
} while ((retrycount) && (! fSuccess || sizeof(cmd) != cbWritten));
if (! fSuccess || sizeof(cmd) != cbWritten)
{
CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Could not write to pipe\n");
DisconnectNamedPipe(hPipe);
return false;
}
// now tell the cache we don't need it's command thread anymore
SecureZeroMemory(&cmd, sizeof(TSVNCacheCommand));
cmd.command = TSVNCACHECOMMAND_END;
WriteFile(
hPipe, // handle to pipe
&cmd, // buffer to write from
sizeof(cmd), // number of bytes to write
&cbWritten, // number of bytes written
NULL); // not overlapped I/O
DisconnectNamedPipe(hPipe);
}
else
{
CTraceToOutputDebugString::Instance()(__FUNCTION__ ": SetNamedPipeHandleState failed");
return false;
}
return true;
}
BOOL CDDStatic::OnRenderGlobalData(LPFORMATETC lpFormatEtc, HGLOBAL* phGlobal)
{
pws_os::Trace(L"CDDStatic::OnRenderGlobalData: %s; ci == %p\n",
lpFormatEtc->cfFormat == CF_UNICODETEXT ? L"CF_UNICODETEXT" : L"CF_TEXT",
m_pci);
if (lpFormatEtc->cfFormat != CF_UNICODETEXT &&
lpFormatEtc->cfFormat != CF_TEXT)
return FALSE;
if (m_hgDataTXT != NULL) {
pws_os::Trace(L"CDDStatic::OnRenderGlobalData - Unlock/Free m_hgDataTXT\n");
GlobalUnlock(m_hgDataTXT);
GlobalFree(m_hgDataTXT);
m_hgDataTXT = NULL;
}
if (m_hgDataUTXT != NULL) {
pws_os::Trace(L"CDDStatic::OnRenderGlobalData - Unlock/Free m_hgDataUTXT\n");
GlobalUnlock(m_hgDataUTXT);
GlobalFree(m_hgDataUTXT);
m_hgDataUTXT = NULL;
}
StringX cs_dragdata;
if (m_pci == NULL) {
if (m_groupname.empty()) {
pws_os::Trace(L"CDDStatic::OnRenderGlobalData - mpci == NULL\n");
return FALSE;
} else {
cs_dragdata = m_groupname;
}
} else { // m_pci != NULL
const CItemData *pci(m_pci);
// Handle shortcut or alias
if ((m_nID == IDC_STATIC_DRAGPASSWORD && pci->IsAlias()) ||
(pci->IsShortcut() && (m_nID != IDC_STATIC_DRAGGROUP &&
m_nID != IDC_STATIC_DRAGTITLE &&
m_nID != IDC_STATIC_DRAGUSER))) {
pci = app.GetMainDlg()->GetBaseEntry(pci);
}
cs_dragdata = GetData(pci);
if (cs_dragdata.empty() && m_nID != IDC_STATIC_DRAGAUTO)
return FALSE;
}
const size_t ilen = cs_dragdata.length();
if (ilen == 0 && m_nID != IDC_STATIC_DRAGAUTO) {
// Nothing to do - why were we even called???
return FALSE;
}
DWORD dwBufLen;
LPSTR lpszA(NULL);
LPWSTR lpszW(NULL);
if (lpFormatEtc->cfFormat == CF_UNICODETEXT) {
// So is requested data!
dwBufLen = (DWORD)((ilen + 1) * sizeof(wchar_t));
lpszW = new WCHAR[ilen + 1];
//pws_os::Trace(L"lpszW allocated %p, size %d\n", lpszW, dwBufLen);
if (ilen == 0) {
lpszW[ilen] = L'\0';
} else {
(void) wcsncpy_s(lpszW, ilen + 1, cs_dragdata.c_str(), ilen);
}
} else {
// They want it in ASCII - use lpszW temporarily
if (ilen == 0) {
dwBufLen = 1;
lpszA = new char[dwBufLen];
lpszA = '\0';
} else {
lpszW = const_cast<LPWSTR>(cs_dragdata.c_str());
dwBufLen = WideCharToMultiByte(CP_ACP, 0, lpszW, -1, NULL, 0, NULL, NULL);
ASSERT(dwBufLen != 0);
lpszA = new char[dwBufLen];
pws_os::Trace(L"lpszA allocated %p, size %d\n", lpszA, dwBufLen);
WideCharToMultiByte(CP_ACP, 0, lpszW, -1, lpszA, dwBufLen, NULL, NULL);
lpszW = NULL;
}
}
LPVOID lpData(NULL);
LPVOID lpDataBuffer;
HGLOBAL *phgData;
if (lpFormatEtc->cfFormat == CF_UNICODETEXT) {
lpDataBuffer = (LPVOID)lpszW;
phgData = &m_hgDataUTXT;
} else {
lpDataBuffer = (LPVOID)lpszA;
phgData = &m_hgDataTXT;
}
BOOL retval(FALSE);
if (*phGlobal == NULL) {
//pws_os::Trace(L"CDDStatic::OnRenderGlobalData - Alloc global memory\n");
*phgData = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwBufLen);
ASSERT(*phgData != NULL);
if (*phgData == NULL)
goto bad_return;
lpData = GlobalLock(*phgData);
ASSERT(lpData != NULL);
if (lpData == NULL)
goto bad_return;
// Copy data
memcpy(lpData, lpDataBuffer, dwBufLen);
*phGlobal = *phgData;
retval = TRUE;
} else {
pws_os::Trace(L"CDDStatic::OnRenderGlobalData - *phGlobal NOT NULL!\n");
SIZE_T inSize = GlobalSize(*phGlobal);
SIZE_T ourSize = GlobalSize(*phgData);
if (inSize < ourSize) {
// Pre-allocated space too small. Not allowed to increase it - FAIL
pws_os::Trace(L"CDDStatic::OnRenderGlobalData - NOT enough room - FAIL\n");
} else {
// Enough room - copy our data into supplied area
pws_os::Trace(L"CDDStatic::OnRenderGlobalData - enough room - copy our data\n");
LPVOID pInGlobalLock = GlobalLock(*phGlobal);
ASSERT(pInGlobalLock != NULL);
if (pInGlobalLock == NULL)
goto bad_return;
memcpy(pInGlobalLock, lpDataBuffer, ourSize);
GlobalUnlock(*phGlobal);
retval = TRUE;
}
}
bad_return:
// Finished with buffer - trash it
trashMemory(lpDataBuffer, dwBufLen);
// Free the strings (only one is actually in use)
//pws_os::Trace(L"lpszA freed %p\n", lpszA);
delete[] lpszA;
//pws_os::Trace(L"lpszW freed %p\n", lpszW);
delete[] lpszW;
// Since lpDataBuffer pointed to one of the above - just zero the pointer
lpDataBuffer = NULL;
// If retval == TRUE, recipient is responsible for freeing the global memory
// if D&D succeeds (see after StartDragging in OnMouseMove)
if (retval == FALSE) {
pws_os::Trace(L"CDDStatic::OnRenderGlobalData - returning FALSE!\n");
if (lpData != NULL) {
GlobalFree(*phgData);
*phgData = NULL;
}
} else {
pws_os::Trace(L"CDDStatic::OnRenderGlobalData - D&D Data:");
if (lpFormatEtc->cfFormat == CF_UNICODETEXT) {
pws_os::Trace(L"\"%ls\"\n", (LPWSTR)lpData); // data is Unicode
} else {
pws_os::Trace(L"\"%hs\"\n", (LPSTR)lpData); // data is NOT Unicode
}
}
// Unlock our buffer
if (lpData != NULL)
GlobalUnlock(*phgData);
return retval;
}
BOOL SetOwner(LPCTSTR filename, LPCTSTR newOwner)
{
PSID sid = nullptr;
BOOL res = TRUE;
PACL pacl = nullptr;
// get the SID for the new owner
TCHAR domainUnused[4096];
DWORD sidSize = 0;
DWORD domainBufSize = 4096;
SID_NAME_USE sidUse;
// pre-flight to determine required size of the sid
LookupAccountName(nullptr, newOwner, nullptr, &sidSize, domainUnused, &domainBufSize, &sidUse);
sid = (PSID)malloc(sidSize);
// determine sid for account name
if (!LookupAccountName(nullptr, newOwner, sid, &sidSize, domainUnused, &domainBufSize, &sidUse)) {
qCritical("failed to look up account name: %ls", newOwner);
res = FALSE;
} else {
EXPLICIT_ACCESS access;
ZeroMemory(&access, sizeof(EXPLICIT_ACCESS));
wchar_t ownerTemp[UNLEN + 1];
wcsncpy(ownerTemp, newOwner, UNLEN + 1);
// Set full control for Administrators.
access.grfAccessPermissions = GENERIC_ALL;
access.grfAccessMode = SET_ACCESS;
access.grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
access.Trustee.TrusteeForm = TRUSTEE_IS_SID;
access.Trustee.TrusteeType = TRUSTEE_IS_GROUP;
access.Trustee.ptstrName = (LPTSTR)sid;
DWORD secRes = SetEntriesInAcl(1, &access, nullptr, &pacl);
if (secRes != ERROR_SUCCESS) {
qCritical("failed to set up acls: %lu", secRes);
return FALSE;
}
// filename parameter for SetNamedSecurityInfo isn't const
// which is odd since it is documented to be a input parameter...
TCHAR *fileNameBuf = new TCHAR[32768];
wcsncpy_s(fileNameBuf, 32768, filename, 32768);
// Set the owner on the file and give him full access
secRes = SetNamedSecurityInfo(
fileNameBuf, SE_FILE_OBJECT,
OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
sid, nullptr, pacl, nullptr);
delete [] fileNameBuf;
if (secRes != NOERROR) {
qCritical("failed to set file owner: %d", secRes);
res = false;
}
}
if (sid != nullptr) {
free(sid);
}
return res;
}
// dumpmemoryw - Dumps a nicely formatted rendition of a region of memory.
// Includes both the hex value of each byte and its Unicode equivalent.
//
// - address (IN): Pointer to the beginning of the memory region to dump.
//
// - size (IN): The size, in bytes, of the region to dump.
//
// Return Value:
//
// None.
//
VOID dumpmemoryw (LPCVOID address, SIZE_T size)
{
BYTE byte;
SIZE_T byteindex;
SIZE_T bytesdone;
SIZE_T dumplen;
WCHAR formatbuf [BYTEFORMATBUFFERLENGTH];
WCHAR hexdump [HEXDUMPLINELENGTH] = {0};
SIZE_T hexindex;
WORD word;
WCHAR unidump [18] = {0};
SIZE_T uniindex;
// Each line of output is 16 bytes.
if ((size % 16) == 0) {
// No padding needed.
dumplen = size;
}
else {
// We'll need to pad the last line out to 16 bytes.
dumplen = size + (16 - (size % 16));
}
// For each word of data, get both the Unicode equivalent and the hex
// representation.
bytesdone = 0;
for (byteindex = 0; byteindex < dumplen; byteindex++) {
hexindex = 3 * ((byteindex % 16) + ((byteindex % 16) / 4)); // 3 characters per byte, plus a 3-character space after every 4 bytes.
uniindex = ((byteindex / 2) % 8) + ((byteindex / 2) % 8) / 8; // 1 character every other byte, plus a 1-character space after every 8 bytes.
if (byteindex < size) {
byte = ((PBYTE)address)[byteindex];
_snwprintf_s(formatbuf, BYTEFORMATBUFFERLENGTH, _TRUNCATE, L"%.2X ", byte);
formatbuf[BYTEFORMATBUFFERLENGTH - 1] = '\0';
wcsncpy_s(hexdump + hexindex, HEXDUMPLINELENGTH - hexindex, formatbuf, 4);
if (((byteindex % 2) == 0) && ((byteindex + 1) < dumplen)) {
// On every even byte, print one character.
word = ((PWORD)address)[byteindex / 2];
if ((word == 0x0000) || (word == 0x0020)) {
unidump[uniindex] = L'.';
}
else {
unidump[uniindex] = word;
}
}
}
else {
// Add padding to fill out the last line to 16 bytes.
wcsncpy_s(hexdump + hexindex, HEXDUMPLINELENGTH - hexindex, L" ", 4);
unidump[uniindex] = L'.';
}
bytesdone++;
if ((bytesdone % 16) == 0) {
// Print one line of data for every 16 bytes. Include the
// ASCII dump and the hex dump side-by-side.
report(L" %s %s\n", hexdump, unidump);
}
else {
if ((bytesdone % 8) == 0) {
// Add a spacer in the ASCII dump after every 8 bytes.
unidump[uniindex + 1] = L' ';
}
if ((bytesdone % 4) == 0) {
// Add a spacer in the hex dump after every 4 bytes.
wcsncpy_s(hexdump + hexindex + 3, HEXDUMPLINELENGTH - hexindex - 3, L" ", 4);
}
}
}
}
// dumpmemorya - Dumps a nicely formatted rendition of a region of memory.
// Includes both the hex value of each byte and its ASCII equivalent (if
// printable).
//
// - address (IN): Pointer to the beginning of the memory region to dump.
//
// - size (IN): The size, in bytes, of the region to dump.
//
// Return Value:
//
// None.
//
VOID dumpmemorya (LPCVOID address, SIZE_T size)
{
WCHAR ascdump [18] = {0};
SIZE_T ascindex;
BYTE byte;
SIZE_T byteindex;
SIZE_T bytesdone;
SIZE_T dumplen;
WCHAR formatbuf [BYTEFORMATBUFFERLENGTH];
WCHAR hexdump [HEXDUMPLINELENGTH] = {0};
SIZE_T hexindex;
// Each line of output is 16 bytes.
if ((size % 16) == 0) {
// No padding needed.
dumplen = size;
}
else {
// We'll need to pad the last line out to 16 bytes.
dumplen = size + (16 - (size % 16));
}
// For each byte of data, get both the ASCII equivalent (if it is a
// printable character) and the hex representation.
bytesdone = 0;
for (byteindex = 0; byteindex < dumplen; byteindex++) {
hexindex = 3 * ((byteindex % 16) + ((byteindex % 16) / 4)); // 3 characters per byte, plus a 3-character space after every 4 bytes.
ascindex = (byteindex % 16) + (byteindex % 16) / 8; // 1 character per byte, plus a 1-character space after every 8 bytes.
if (byteindex < size) {
byte = ((PBYTE)address)[byteindex];
_snwprintf_s(formatbuf, BYTEFORMATBUFFERLENGTH, _TRUNCATE, L"%.2X ", byte);
formatbuf[3] = '\0';
wcsncpy_s(hexdump + hexindex, HEXDUMPLINELENGTH - hexindex, formatbuf, 4);
if (isgraph(byte)) {
ascdump[ascindex] = (WCHAR)byte;
}
else {
ascdump[ascindex] = L'.';
}
}
else {
// Add padding to fill out the last line to 16 bytes.
wcsncpy_s(hexdump + hexindex, HEXDUMPLINELENGTH - hexindex, L" ", 4);
ascdump[ascindex] = L'.';
}
bytesdone++;
if ((bytesdone % 16) == 0) {
// Print one line of data for every 16 bytes. Include the
// ASCII dump and the hex dump side-by-side.
report(L" %s %s\n", hexdump, ascdump);
}
else {
if ((bytesdone % 8) == 0) {
// Add a spacer in the ASCII dump after every 8 bytes.
ascdump[ascindex + 1] = L' ';
}
if ((bytesdone % 4) == 0) {
// Add a spacer in the hex dump after every 4 bytes.
wcsncpy_s(hexdump + hexindex + 3, HEXDUMPLINELENGTH - hexindex - 3, L" ", 4);
}
}
}
}
HRESULT CLAVSplitterSettingsProp::OnActivate()
{
HRESULT hr = S_OK;
INITCOMMONCONTROLSEX icc;
icc.dwSize = sizeof(INITCOMMONCONTROLSEX);
icc.dwICC = ICC_BAR_CLASSES | ICC_STANDARD_CLASSES;
if (InitCommonControlsEx(&icc) == FALSE)
{
return E_FAIL;
}
ASSERT(m_pLAVF != nullptr);
const WCHAR *version = TEXT(LAV_SPLITTER) L" " TEXT(LAV_VERSION_STR);
SendDlgItemMessage(m_Dlg, IDC_SPLITTER_FOOTER, WM_SETTEXT, 0, (LPARAM)version);
hr = LoadData();
memset(m_subLangBuffer, 0, sizeof(m_advSubBuffer));
memset(m_advSubBuffer, 0, sizeof(m_advSubBuffer));
m_selectedSubMode = LAVSubtitleMode_Default;
if (m_pszAdvSubConfig)
wcsncpy_s(m_advSubBuffer, m_pszAdvSubConfig, _TRUNCATE);
// Notify the UI about those settings
SendDlgItemMessage(m_Dlg, IDC_PREF_LANG, WM_SETTEXT, 0, (LPARAM)m_pszPrefLang);
SendDlgItemMessage(m_Dlg, IDC_PREF_LANG_SUBS, WM_SETTEXT, 0, (LPARAM)m_pszPrefSubLang);
// Init the Combo Box
SendDlgItemMessage(m_Dlg, IDC_SUBTITLE_MODE, CB_RESETCONTENT, 0, 0);
WideStringFromResource(stringBuffer, IDS_SUBMODE_NO_SUBS);
SendDlgItemMessage(m_Dlg, IDC_SUBTITLE_MODE, CB_ADDSTRING, 0, (LPARAM)stringBuffer);
WideStringFromResource(stringBuffer, IDS_SUBMODE_FORCED_SUBS);
SendDlgItemMessage(m_Dlg, IDC_SUBTITLE_MODE, CB_ADDSTRING, 0, (LPARAM)stringBuffer);
WideStringFromResource(stringBuffer, IDS_SUBMODE_DEFAULT);
SendDlgItemMessage(m_Dlg, IDC_SUBTITLE_MODE, CB_ADDSTRING, 0, (LPARAM)stringBuffer);
WideStringFromResource(stringBuffer, IDS_SUBMODE_ADVANCED);
SendDlgItemMessage(m_Dlg, IDC_SUBTITLE_MODE, CB_ADDSTRING, 0, (LPARAM)stringBuffer);
SendDlgItemMessage(m_Dlg, IDC_SUBTITLE_MODE, CB_SETCURSEL, m_subtitleMode, 0);
addHint(IDC_SUBTITLE_MODE, L"Configure how subtitles are selected.");
SendDlgItemMessage(m_Dlg, IDC_BD_SEPARATE_FORCED_SUBS, BM_SETCHECK, m_PGSForcedStream, 0);
addHint(IDC_BD_SEPARATE_FORCED_SUBS, L"Enabling this causes the creation of a new \"Forced Subtitles\" stream, which will try to always display forced subtitles matching your selected audio language.\n\nNOTE: This option may not work on all Blu-ray discs.\nRequires restart to take effect.");
SendDlgItemMessage(m_Dlg, IDC_BD_ONLY_FORCED_SUBS, BM_SETCHECK, m_PGSOnlyForced, 0);
addHint(IDC_BD_ONLY_FORCED_SUBS, L"When enabled, all Blu-ray (PGS) subtitles will be filtered, and only forced subtitles will be sent to the renderer.\n\nNOTE: When this option is active, you will not be able to get the \"full\" subtitles.");
SendDlgItemMessage(m_Dlg, IDC_VC1TIMESTAMP, BM_SETCHECK, m_VC1Mode, 0);
addHint(IDC_VC1TIMESTAMP, L"Checked - Frame timings will be corrected.\nUnchecked - Frame timings will be sent untouched.\nIndeterminate (Auto) - Only enabled for decoders that rely on the splitter doing the corrections.\n\nNOTE: Only for debugging, if unsure, set to \"Auto\".");
SendDlgItemMessage(m_Dlg, IDC_MKV_EXTERNAL, BM_SETCHECK, m_MKVExternal, 0);
SendDlgItemMessage(m_Dlg, IDC_SUBSTREAMS, BM_SETCHECK, m_substreams, 0);
addHint(IDC_SUBSTREAMS, L"Controls if sub-streams should be exposed as a separate stream.\nSub-streams are typically streams for backwards compatibility, for example the AC3 part of TrueHD streams on Blu-rays.");
SendDlgItemMessage(m_Dlg, IDC_STREAM_SWITCH_REMOVE_AUDIO, BM_SETCHECK, m_StreamSwitchRemoveAudio, 0);
addHint(IDC_STREAM_SWITCH_REMOVE_AUDIO, L"Remove the old Audio Decoder from the Playback Chain before switching the audio stream, forcing DirectShow to select a new one.\n\nThis option ensures that the preferred decoder is always used, however it does not work properly with all players.");
addHint(IDC_SELECT_AUDIO_QUALITY, L"Controls if the stream with the highest quality (matching your language preferences) should always be used.\nIf disabled, the first stream is always used.");
SendDlgItemMessage(m_Dlg, IDC_SELECT_AUDIO_QUALITY, BM_SETCHECK, m_PreferHighQualityAudio, 0);
SendDlgItemMessage(m_Dlg, IDC_IMPAIRED_AUDIO, BM_SETCHECK, m_ImpairedAudio, 0);
SendDlgItemMessage(m_Dlg, IDC_QUEUE_MEM_SPIN, UDM_SETRANGE32, 0, 2048);
addHint(IDC_QUEUE_MEM, L"Set the maximum memory a frame queue can use for buffering (in megabytes).\nNote that this is the maximum value, only very high bitrate files will usually even reach the default maximum value.");
addHint(IDC_QUEUE_MEM_SPIN, L"Set the maximum memory a frame queue can use for buffering (in megabytes).\nNote that this is the maximum value, only very high bitrate files will usually even reach the default maximum value.");
WCHAR stringBuffer[100];
swprintf_s(stringBuffer, L"%d", m_QueueMaxMem);
SendDlgItemMessage(m_Dlg, IDC_QUEUE_MEM, WM_SETTEXT, 0, (LPARAM)stringBuffer);
SendDlgItemMessage(m_Dlg, IDC_QUEUE_PACKETS_SPIN, UDM_SETRANGE32, 100, 100000);
addHint(IDC_QUEUE_PACKETS, L"Set the maximum numbers of packets to buffer in the frame queue.\nNote that the frame queue will never exceed the memory limited set above.");
addHint(IDC_QUEUE_PACKETS_SPIN, L"Set the maximum numbers of packets to buffer in the frame queue.\nNote that the frame queue will never exceed the memory limited set above.");
swprintf_s(stringBuffer, L"%d", m_QueueMaxPackets);
SendDlgItemMessage(m_Dlg, IDC_QUEUE_PACKETS, WM_SETTEXT, 0, (LPARAM)stringBuffer);
SendDlgItemMessage(m_Dlg, IDC_STREAM_ANADUR_SPIN, UDM_SETRANGE32, 200, 10000);
addHint(IDC_STREAM_ANADUR, L"Set the duration (in milliseconds) a network stream is analyzed for before playback starts.\nA longer duration ensures the stream parameters are properly detected, however it will delay playback start.\n\nDefault: 1000 (1 second)");
addHint(IDC_STREAM_ANADUR_SPIN, L"Set the duration (in milliseconds) a network stream is analyzed for before playback starts.\nA longer duration ensures the stream parameters are properly detected, however it will delay playback start.\n\nDefault: 1000 (1 second)");
swprintf_s(stringBuffer, L"%d", m_NetworkAnalysisDuration);
SendDlgItemMessage(m_Dlg, IDC_STREAM_ANADUR, WM_SETTEXT, 0, (LPARAM)stringBuffer);
UpdateSubtitleMode(m_subtitleMode);
SendDlgItemMessage(m_Dlg, IDC_TRAYICON, BM_SETCHECK, m_TrayIcon, 0);
return hr;
}
BOOL ShellCache::IsPathAllowed(LPCTSTR path)
{
ValidatePathFilter();
Locker lock(m_critSec);
svn_tristate_t allowed = pathFilter.IsPathAllowed (path);
if (allowed != svn_tristate_unknown)
return allowed == svn_tristate_true ? TRUE : FALSE;
UINT drivetype = 0;
int drivenumber = PathGetDriveNumber(path);
if ((drivenumber >=0)&&(drivenumber < 25))
{
drivetype = drivetypecache[drivenumber];
if ((drivetype == -1)||((GetTickCount64() - drivetypeticker)>DRIVETYPETIMEOUT))
{
if ((DWORD(drivefloppy) == 0)&&((drivenumber == 0)||(drivenumber == 1)))
drivetypecache[drivenumber] = DRIVE_REMOVABLE;
else
{
drivetypeticker = GetTickCount64();
TCHAR pathbuf[MAX_PATH + 4] = { 0 }; // MAX_PATH ok here. PathStripToRoot works with partial paths too.
wcsncpy_s(pathbuf, path, _countof(pathbuf)-1);
PathStripToRoot(pathbuf);
PathAddBackslash(pathbuf);
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": GetDriveType for %s, Drive %d\n", pathbuf, drivenumber);
drivetype = GetDriveType(pathbuf);
drivetypecache[drivenumber] = drivetype;
}
}
}
else
{
TCHAR pathbuf[MAX_PATH + 4] = { 0 }; // MAX_PATH ok here. PathIsUNCServer works with partial paths too.
wcsncpy_s(pathbuf, path, _countof(pathbuf)-1);
if (PathIsUNCServer(pathbuf))
drivetype = DRIVE_REMOTE;
else
{
PathStripToRoot(pathbuf);
PathAddBackslash(pathbuf);
if (wcsncmp(pathbuf, drivetypepathcache, MAX_PATH-1)==0) // MAX_PATH ok.
drivetype = drivetypecache[26];
else
{
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L"GetDriveType for %s\n", pathbuf);
drivetype = GetDriveType(pathbuf);
drivetypecache[26] = drivetype;
wcsncpy_s(drivetypepathcache, pathbuf, MAX_PATH); // MAX_PATH ok.
}
}
}
if ((drivetype == DRIVE_REMOVABLE)&&(!IsRemovable()))
return FALSE;
if ((drivetype == DRIVE_FIXED)&&(!IsFixed()))
return FALSE;
if (((drivetype == DRIVE_REMOTE)||(drivetype == DRIVE_NO_ROOT_DIR))&&(!IsRemote()))
return FALSE;
if ((drivetype == DRIVE_CDROM)&&(!IsCDRom()))
return FALSE;
if ((drivetype == DRIVE_RAMDISK)&&(!IsRAM()))
return FALSE;
if ((drivetype == DRIVE_UNKNOWN)&&(IsUnknown()))
return FALSE;
return TRUE;
}
//-----------------------------------------------------------------------------
static void process_dir_watcher_results(
watch_entry *watch_entry_p,
DWORD buffer_size){
//-----------------------------------------------------------------------------
HANDLE hChangeLog;
PFILE_NOTIFY_INFORMATION buffer_p;
DWORD buffer_index;
BOOL more;
SSIZE_T path_len;
int compare_result;
BOOL exclude;
struct exclude_entry * exclude_entry_p;
DWORD error_code;
errno_t copy_result;
LPWSTR fmt, slash_pos;
hChangeLog = INVALID_HANDLE_VALUE;
more = TRUE;
buffer_index = 0;
// If buffer size is 0, indicates that too many changes occurred to fit in the buffer
// Write out the top level dir to trigger the monitor to do a full pass of it
if (buffer_size == 0){
more = FALSE;
copy_result = wcsncpy_s(full_file_name, ARRAYSIZE(full_file_name),
watch_entry_p->dir_path, watch_entry_p->dir_path_len);
if (copy_result != 0){
report_error(L"wcsncpy_s failed", copy_result);
ExitProcess(28);
}
write_path_to_temp_file(full_file_name, ARRAYSIZE(full_file_name), &hChangeLog);
}
while (more) {
buffer_p = (PFILE_NOTIFY_INFORMATION) &watch_entry_p->changes_buffer[buffer_index];
// Cannot use just sizeof(FILE_NOTIFY_INFORMATION) as it includes 2 bytes of struct padding,
// causing this check to fail for single-character filenames
size_t entry_size = offsetof(FILE_NOTIFY_INFORMATION, FileName) + buffer_p->FileNameLength;
if ((buffer_index + entry_size) > buffer_size) {
_wfopen_s(&error_file, error_path, L"w");
fwprintf(
error_file,
L"process_dir_watcher_results buffer overrun %d %d\n",
buffer_index,
buffer_size
);
fclose(error_file);
ExitProcess(18);
}
copy_result = wcsncpy_s(relative_file_name, ARRAYSIZE(relative_file_name),
buffer_p->FileName, buffer_p->FileNameLength/sizeof(wchar_t));
if (copy_result != 0){
report_error(L"wcsncpy_s failed", copy_result);
ExitProcess(25);
}
// 2010-09-05 dougfort -- if the dir_path ends in a slash
// (probably something like c:\) then we don't want to
// interpolate another slash
if (watch_entry_p->dir_path[watch_entry_p->dir_path_len-1] == L'\\')
fmt = L"%s%s";
else
fmt = L"%s\\%s";
path_len = _snwprintf_s(full_file_name, ARRAYSIZE(full_file_name), _TRUNCATE,
fmt, watch_entry_p->dir_path, relative_file_name);
if (path_len == -1){
report_error(L"_snwprintf_s failed, path too long",
(DWORD)(watch_entry_p->dir_path_len + wcslen(relative_file_name)));
ExitProcess(26);
}
// We want the directory where the event took place,
// for consistency with OSX.
// Needs to be done before calling GetLongPathName since in the case of
// a rename or delete the actual file itself is already gone
if (full_file_name[path_len-1] != L'\\') {
slash_pos = wcsrchr(full_file_name, L'\\');
if (slash_pos)
*slash_pos = L'\0';
}
// Need to translate short names before checking excludes
// According to MSDN docs, you can reuse the same buffer for output
path_len = GetLongPathNameW(
full_file_name,
full_file_name,
ARRAYSIZE(full_file_name)
);
// Note that most of errors that occurred here were due to a buffer overflow
// which has since been fixed. In case of error, pass orig filename unchanged and
// let code that picks up output deal with removed folders, etc
if (path_len == 0) {
error_code = GetLastError();
report_error(L"GetLongPathNameW", error_code);
path_len=wcslen(full_file_name);
}
else if (path_len > ARRAYSIZE(full_file_name)){
// Shouldn't happen since buffer is maximum possible path length
report_error(L"GetLongPathNameW result would overflow buffer", (DWORD)path_len);
ExitProcess(27);
}
// Can check for excludes last since we only ever exclude folders
exclude = FALSE;
for (
exclude_entry_p=exclude_entry_list_p;
exclude_entry_p != NULL;
exclude_entry_p = exclude_entry_p->next_p
) {
compare_result = _wcsnicmp(
full_file_name,
exclude_entry_p->dir_path,
exclude_entry_p->dir_path_len
);
if (0 == compare_result) {
exclude = TRUE;
break;
}
}
if (exclude) {
if (0 == buffer_p->NextEntryOffset) {
more = FALSE;
} else {
buffer_index += buffer_p->NextEntryOffset;
}
continue;
}
write_path_to_temp_file(full_file_name, ARRAYSIZE(full_file_name), &hChangeLog);
if (0 == buffer_p->NextEntryOffset) {
more = FALSE;
} else {
buffer_index += buffer_p->NextEntryOffset;
}
} // while (more)
if (hChangeLog != INVALID_HANDLE_VALUE) {
CloseHandle(hChangeLog);
notification_sequence++;
wsprintf(
notification_file_path, // LPTSTR pszDest,
L"%s\\%08d.txt", // LPCTSTR pszFormat
notification_path,
notification_sequence
);
if (_wrename(temp_file_path, notification_file_path) != 0) {
_wfopen_s(&error_file, error_path, L"w");
_wcserror_s(
error_buffer, sizeof error_buffer/sizeof(wchar_t), errno
);
fwprintf(
error_file,
L"_wrename(%s, %s) failed: (%d) %s\n",
temp_file_path,
notification_file_path,
errno,
error_buffer
);
fclose(error_file);
ExitProcess(24);
}
}
} // static void process_dir_watcher_results(
SimpleEventListener(LPWSTR type)
{
wcsncpy_s(m_eventType, 100, type, 100);
m_eventType[99] = 0;
}
/////////////////////////////////////////////////////////
//
// GetComponentInfo
//
// This helper function, provided with a component
// ProgId, gathers the component's name and version
// info and formats them into output strings
//
// Parameters:
// CLSID clsid : [in] component's CLSID
// SInfo& info : [in, out] a structure of buffers
// to get the formatted strings into
//
// Return Values:
// TRUE, if the function succeeds
// FALSE, if it fails
//
/////////////////////////////////////////////////////////
BOOL GetComponentInfo(CLSID clsid, SInfo& info)
{
info.wchName[0] = info.wchVersion[0] = 0;
// Format Registry Key string
WCHAR wszKey[45] = L"CLSID\\"; // the key buffer should be large enough for a string
// like "CLSID\{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}"
// Convert CLSID to String
UINT uPos = lstrlenW(wszKey);
if (0 == StringFromGUID2(clsid, &wszKey[uPos], countof(wszKey) - uPos))
return FALSE;
wszKey[countof(wszKey)-1] = 0;
// Open key to find path of application
HKEY hKeyRoot;
if (RegOpenKeyExW(HKEY_CLASSES_ROOT, wszKey, 0, KEY_READ, &hKeyRoot) != ERROR_SUCCESS)
return FALSE;
// Query value of key to get the name of the component
ULONG cSize = sizeof(info.wchName); // size of the buffer in bytes
if (RegQueryValueExW(hKeyRoot, NULL, NULL, NULL, (BYTE*)info.wchName, &cSize) != ERROR_SUCCESS)
{
RegCloseKey(hKeyRoot);
return FALSE;
}
info.wchName[countof(info.wchName) - 1] = 0;
// Open the version info subkey
UINT iVersionMaxLen = countof(info.wchVersion);
HKEY hKey = NULL;
if (RegOpenKeyExW(hKeyRoot, L"Version", 0, KEY_READ, &hKey) == ERROR_SUCCESS)
{
const WCHAR* pcwsVersion = L"version ";
UINT iLen = lstrlenW(pcwsVersion);
// Query value of key to get version string
if (iLen < iVersionMaxLen)
{
// copy the "version " string including terminating 0
wcsncpy_s(info.wchVersion, iVersionMaxLen, pcwsVersion, iLen + 1);
// get the version string
cSize = (iVersionMaxLen - iLen) * sizeof(WCHAR); // the size is in bytes
if (RegQueryValueExW(hKey, NULL, NULL, NULL,
(BYTE*)&info.wchVersion[iLen],
&cSize) == ERROR_SUCCESS)
{
info.wchVersion[iVersionMaxLen-1] = 0;
}
}
RegCloseKey(hKey);
}
// Open InprocServer32 subkey to get the path to the component
if (RegOpenKeyExW(hKeyRoot, L"InprocServer32", 0, KEY_READ, &hKey) == ERROR_SUCCESS)
{
// Query value of key to get the path string
WCHAR wchPath[MAX_PATH];
cSize = sizeof(wchPath);
if (RegQueryValueExW(hKey, NULL, NULL, NULL, (BYTE*)wchPath, &cSize) == ERROR_SUCCESS)
{
// Get the build number from the file version info
DWORD dwHandle = 0;
cSize = GetFileVersionInfoSizeW(wchPath, &dwHandle); // returns the size in bytes
WCHAR* pwchFileVerInfo = NULL;
if (cSize)
{
pwchFileVerInfo = (WCHAR*)new BYTE[cSize];
}
if (NULL != pwchFileVerInfo)
{
// Retrieve version information for the file
if (GetFileVersionInfoW(wchPath, 0, cSize, pwchFileVerInfo))
{
// Get the default language id and code page number
UINT *pdwLang;
UINT cch = 0;
if (VerQueryValueW(pwchFileVerInfo, L"\\VarFileInfo\\Translation",
(void**)&pdwLang, &cch) == TRUE)
{
// Read the file description for the language and code page.
const int MAX_SUBBLOCK = 40;
WCHAR wchSubBlock[MAX_SUBBLOCK]; // large enough for the string
StringCchPrintfExW(wchSubBlock,
MAX_SUBBLOCK,
NULL,
NULL,
STRSAFE_NULL_ON_FAILURE,
L"\\StringFileInfo\\%04x%04x\\FileVersion",
LOWORD(*pdwLang), HIWORD(*pdwLang));
WCHAR* pwchBuildVer = NULL;
if ((VerQueryValueW(pwchFileVerInfo, wchSubBlock,
(void**)&pwchBuildVer, &cch) == TRUE)
&& (NULL != pwchBuildVer))
{
// Format the version string
UINT iLen = (UINT)lstrlenW(info.wchVersion);
if (0 < iLen)
{
if (iLen < iVersionMaxLen)
{
const WCHAR* pcwsBuild = L", build ";
wcsncpy_s(info.wchVersion + iLen, iVersionMaxLen - iLen, pcwsBuild, iVersionMaxLen - iLen);
iLen += lstrlenW(pcwsBuild);
if (iLen < iVersionMaxLen)
{
wcsncpy_s(info.wchVersion + iLen, iVersionMaxLen - iLen, pwchBuildVer, iVersionMaxLen - iLen);
}
}
}
else
{
wcsncpy_s(info.wchVersion, iVersionMaxLen, pwchBuildVer, iVersionMaxLen);
}
info.wchVersion[iVersionMaxLen-1] = 0;
}
}
}
delete [] pwchFileVerInfo;
}
}
RegCloseKey(hKey);
}
RegCloseKey(hKeyRoot);
return TRUE;
}
void CNHSQLServerDBO::SetLogFilePath(const wchar_t *const pFilePath)
{
assert(NULL != pFilePath);
wcsncpy_s(m_wchLogFilePath, _countof(m_wchLogFilePath), pFilePath, _TRUNCATE);
}
bool CCacheDlg::GetStatusFromRemoteCache(const CTGitPath& Path, bool bRecursive)
{
if(!EnsurePipeOpen())
{
STARTUPINFO startup;
PROCESS_INFORMATION process;
memset(&startup, 0, sizeof(startup));
startup.cb = sizeof(startup);
memset(&process, 0, sizeof(process));
CString sCachePath = _T("TGitCache.exe");
if (CreateProcess(sCachePath.GetBuffer(sCachePath.GetLength()+1), _T(""), NULL, NULL, FALSE, 0, 0, 0, &startup, &process)==0)
{
// It's not appropriate to do a message box here, because there may be hundreds of calls
sCachePath.ReleaseBuffer();
ATLTRACE("Failed to start cache\n");
return false;
}
sCachePath.ReleaseBuffer();
// Wait for the cache to open
long endTime = (long)GetTickCount()+1000;
while(!EnsurePipeOpen())
{
if(((long)GetTickCount() - endTime) > 0)
{
return false;
}
}
}
DWORD nBytesRead;
TGITCacheRequest request;
request.flags = TGITCACHE_FLAGS_NONOTIFICATIONS;
if(bRecursive)
{
request.flags |= TGITCACHE_FLAGS_RECUSIVE_STATUS;
}
wcsncpy_s(request.path, Path.GetWinPath(), MAX_PATH);
SecureZeroMemory(&m_Overlapped, sizeof(OVERLAPPED));
m_Overlapped.hEvent = m_hEvent;
// Do the transaction in overlapped mode.
// That way, if anything happens which might block this call
// we still can get out of it. We NEVER MUST BLOCK THE SHELL!
// A blocked shell is a very bad user impression, because users
// who don't know why it's blocked might find the only solution
// to such a problem is a reboot and therefore they might loose
// valuable data.
// Sure, it would be better to have no situations where the shell
// even can get blocked, but the timeout of 5 seconds is long enough
// so that users still recognize that something might be wrong and
// report back to us so we can investigate further.
TGITCacheResponse ReturnedStatus;
BOOL fSuccess = TransactNamedPipe(m_hPipe,
&request, sizeof(request),
&ReturnedStatus, sizeof(ReturnedStatus),
&nBytesRead, &m_Overlapped);
if (!fSuccess)
{
if (GetLastError()!=ERROR_IO_PENDING)
{
ClosePipe();
return false;
}
// TransactNamedPipe is working in an overlapped operation.
// Wait for it to finish
DWORD dwWait = WaitForSingleObject(m_hEvent, INFINITE);
if (dwWait == WAIT_OBJECT_0)
{
fSuccess = GetOverlappedResult(m_hPipe, &m_Overlapped, &nBytesRead, FALSE);
return TRUE;
}
else
fSuccess = FALSE;
}
ClosePipe();
return false;
}
void LoadConfig()
{
BOOL servtmp;
WCHAR hosttmp[MAX_SKKSERVER_HOST]; //ホスト
WCHAR porttmp[MAX_SKKSERVER_PORT]; //ポート
DWORD encodingtmp;
DWORD timeouttmp;
std::wstring strxmlval;
ReadValue(pathconfigxml, SectionServer, ValueServerServ, strxmlval);
servtmp = _wtoi(strxmlval.c_str());
if(servtmp != TRUE && servtmp != FALSE)
{
servtmp = FALSE;
}
ReadValue(pathconfigxml, SectionServer, ValueServerHost, strxmlval);
wcsncpy_s(hosttmp, strxmlval.c_str(), _TRUNCATE);
ReadValue(pathconfigxml, SectionServer, ValueServerPort, strxmlval);
wcsncpy_s(porttmp, strxmlval.c_str(), _TRUNCATE);
ReadValue(pathconfigxml, SectionServer, ValueServerEncoding, strxmlval);
encodingtmp = _wtoi(strxmlval.c_str());
if(encodingtmp != 1)
{
encodingtmp = 0;
}
ReadValue(pathconfigxml, SectionServer, ValueServerTimeOut, strxmlval);
timeouttmp = _wtoi(strxmlval.c_str());
if(timeouttmp > 60000)
{
timeouttmp = 1000;
}
//変更があったら接続し直す
if(servtmp != serv || wcscmp(hosttmp, host) != 0 || wcscmp(porttmp, port) != 0 ||
encodingtmp != encoding || timeouttmp != timeout)
{
serv = servtmp;
wcsncpy_s(host, hosttmp, _TRUNCATE);
wcsncpy_s(port, porttmp, _TRUNCATE);
encoding = encodingtmp;
timeout = timeouttmp;
DisconnectSKKServer();
if(serv)
{
ConnectSKKServer();
GetSKKServerInfo(SKK_VER);
}
}
ReadValue(pathconfigxml, SectionBehavior, ValuePrecedeOkuri, strxmlval);
precedeokuri = _wtoi(strxmlval.c_str());
if(precedeokuri != TRUE && precedeokuri != FALSE)
{
precedeokuri = FALSE;
}
ReadValue(pathconfigxml, SectionBehavior, ValueCompIncBack, strxmlval);
compincback = _wtoi(strxmlval.c_str());
if(compincback != TRUE && compincback != FALSE)
{
compincback = FALSE;
}
}
void CCacheDlg::RemoveFromCache(const CString& path)
{
// if we use the external cache, we tell the cache directly that something
// has changed, without the detour via the shell.
HANDLE hPipe = CreateFile(
GetCacheCommandPipeName(), // pipe name
GENERIC_READ | // read and write access
GENERIC_WRITE,
0, // no sharing
NULL, // default security attributes
OPEN_EXISTING, // opens existing pipe
FILE_FLAG_OVERLAPPED, // default attributes
NULL); // no template file
if (hPipe != INVALID_HANDLE_VALUE)
{
// The pipe connected; change to message-read mode.
DWORD dwMode;
dwMode = PIPE_READMODE_MESSAGE;
if(SetNamedPipeHandleState(
hPipe, // pipe handle
&dwMode, // new pipe mode
NULL, // don't set maximum bytes
NULL)) // don't set maximum time
{
DWORD cbWritten;
TGITCacheCommand cmd;
cmd.command = TGITCACHECOMMAND_CRAWL;
wcsncpy_s(cmd.path, path, MAX_PATH);
BOOL fSuccess = WriteFile(
hPipe, // handle to pipe
&cmd, // buffer to write from
sizeof(cmd), // number of bytes to write
&cbWritten, // number of bytes written
NULL); // not overlapped I/O
if (! fSuccess || sizeof(cmd) != cbWritten)
{
DisconnectNamedPipe(hPipe);
CloseHandle(hPipe);
hPipe = INVALID_HANDLE_VALUE;
}
if (hPipe != INVALID_HANDLE_VALUE)
{
// now tell the cache we don't need it's command thread anymore
DWORD cbWritten;
TGITCacheCommand cmd;
cmd.command = TGITCACHECOMMAND_END;
WriteFile(
hPipe, // handle to pipe
&cmd, // buffer to write from
sizeof(cmd), // number of bytes to write
&cbWritten, // number of bytes written
NULL); // not overlapped I/O
DisconnectNamedPipe(hPipe);
CloseHandle(hPipe);
hPipe = INVALID_HANDLE_VALUE;
}
}
else
{
ATLTRACE("SetNamedPipeHandleState failed");
CloseHandle(hPipe);
}
}
}
int CMediaLibrary::GetExtendedFileInfo(const wchar_t *fn, const wchar_t *Metadata, wchar_t *dest, size_t destlen)
{
bool FindTag;
int RetCode;
::EnterCriticalSection(&CriticalSection);
if (std::wstring(fn) != FileName)
{
FindTag = GetTagInfo(fn);
}
else
{
FindTag = true;
}
if (FindTag) {
wchar_t Buff[MAX_MUSICTEXT];
const char *MetaData = reinterpret_cast<const char*>(Metadata);
if (_stricmp(MetaData, "length") == 0) {
_ultow_s(TagDataW.Length, dest, destlen, 10);
RetCode = 1;
}
else if (_stricmp(MetaData, "formatinformation") == 0) {
wcsncpy_s(dest, destlen, TagDataW.Format.c_str(), _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "type") == 0) {
Buff[0] = '0';
Buff[1] = 0;
wcsncpy_s(dest, destlen, Buff, _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "family") == 0) {
wcsncpy_s(dest, destlen, L"The True Audio File", _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "lossless") == 0) {
Buff[0] = '1';
wcsncpy_s(dest, destlen, Buff, _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "title") == 0) {
wcsncpy_s(dest, destlen, TagDataW.Title.c_str(), _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "artist") == 0) {
wcsncpy_s(dest, destlen, TagDataW.Artist.c_str(), _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "albumartist") == 0) {
wcsncpy_s(dest, destlen, TagDataW.AlbumArtist.c_str(), _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "comment") == 0) {
wcsncpy_s(dest, destlen, TagDataW.Comment.c_str(), _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "album") == 0) {
wcsncpy_s(dest, destlen, TagDataW.Album.c_str(), _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "year") == 0) {
wcsncpy_s(dest, destlen, TagDataW.Year.c_str(), _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "genre") == 0) {
wcsncpy_s(dest, destlen, TagDataW.Genre.c_str(), _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "track") == 0) {
wcsncpy_s(dest, destlen, TagDataW.Track.c_str(), _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "composer") == 0) {
wcsncpy_s(dest, destlen, TagDataW.Composer.c_str(), _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "publisher") == 0) {
wcsncpy_s(dest, destlen, TagDataW.Publisher.c_str(), _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "disc") == 0) {
wcsncpy_s(dest, destlen, TagDataW.Disc.c_str(), _TRUNCATE);
RetCode = 1;
}
else if (_stricmp(MetaData, "bpm") == 0) {
wcsncpy_s(dest, destlen, TagDataW.BPM.c_str(), _TRUNCATE);
RetCode = 1;
}
else {
RetCode = 0;
}
}
else {
FileName = L"";
RetCode = 0;
}
::LeaveCriticalSection(&CriticalSection);
return RetCode;
}
// helper function to parse node in tldString
int readTldString(tldnode* node, const wchar_t* s, int len, int pos) {
int start = pos;
int state = 0;
memset(node, 0, sizeof(tldnode));
do {
wchar_t c = *(s+pos);
switch(state) {
case 0: // general read
if (c==L',' || c==L')' || c==L'(') {
// add last domain
int count = node->attr == THIS ? pos - start : pos - start + 1;
node->dom = (wchar_t*) malloc(count * sizeof(wchar_t));
wcsncpy_s(node->dom, count, s+start, _TRUNCATE);
if (c==L'(') {
// read number of children
start = pos;
state = 1;
} else if (c==L')' || c==L',') {
// return to parent domains
return pos;
}
} else if (c==L'!') {
node->attr=THIS;
}
break;
case 1: // reading number of elements (<number>:
if (c==L':') {
int count = pos - start;
wchar_t* buf = (wchar_t*) malloc(count * sizeof(wchar_t));
wcsncpy_s(buf, count, s+start+1, _TRUNCATE);
node->num_children = wcstol(buf, NULL, 10);
free(buf);
// allocate space for children
node->subnodes = (tldnode**) malloc(node->num_children * sizeof(tldnode*));
int i;
for (i=0; i<node->num_children; i++) {
tldnode* subnode = (tldnode*)malloc(sizeof(tldnode));
pos = readTldString(subnode, s, len, pos + 1);
node->subnodes[i] = subnode;
}
// sort alphabetically for better search performance
sort(node->subnodes, node->subnodes + node->num_children,
[] (const tldnode* node1, const tldnode* node2) -> bool {
// asterisks always comes first
if (wcscmp(node1->dom, ALL) == 0) return true;
if (wcscmp(node2->dom, ALL) == 0) return false;
return wcscmp(node1->dom, node2->dom) < 0;
}
);
return pos + 1;
}
break;
}
pos++;
} while (pos < len);
return pos;
}
AddrInfo GetAddr(uint32_t module, uint64_t addr)
{
AddrInfo ret;
ZeroMemory(&ret, sizeof(ret));
if(module > 0 && module <= modules.size())
{
SymTagEnum tag = SymTagFunction;
IDiaSymbol *pFunc = NULL;
HRESULT hr = modules[module - 1].pSession->findSymbolByVA(addr, tag, &pFunc);
if(hr != S_OK)
{
if(pFunc)
pFunc->Release();
// try again looking for public symbols
tag = SymTagPublicSymbol;
hr = modules[module - 1].pSession->findSymbolByVA(addr, tag, &pFunc);
if(hr != S_OK)
{
if(pFunc)
pFunc->Release();
return ret;
}
}
DWORD opts = 0;
opts |= UNDNAME_NO_LEADING_UNDERSCORES;
opts |= UNDNAME_NO_MS_KEYWORDS;
opts |= UNDNAME_NO_FUNCTION_RETURNS;
opts |= UNDNAME_NO_ALLOCATION_MODEL;
opts |= UNDNAME_NO_ALLOCATION_LANGUAGE;
opts |= UNDNAME_NO_THISTYPE;
opts |= UNDNAME_NO_ACCESS_SPECIFIERS;
opts |= UNDNAME_NO_THROW_SIGNATURES;
opts |= UNDNAME_NO_MEMBER_TYPE;
opts |= UNDNAME_NO_RETURN_UDT_MODEL;
opts |= UNDNAME_32_BIT_DECODE;
opts |= UNDNAME_NO_LEADING_UNDERSCORES;
// first try undecorated name
BSTR file;
hr = pFunc->get_undecoratedNameEx(opts, &file);
// if not, just try name
if(hr != S_OK)
{
hr = pFunc->get_name(&file);
if(hr != S_OK)
{
pFunc->Release();
SysFreeString(file);
return ret;
}
wcsncpy_s(ret.funcName, file, 126);
}
else
{
wcsncpy_s(ret.funcName, file, 126);
wchar_t *voidparam = wcsstr(ret.funcName, L"(void)");
// remove stupid (void) for empty parameters
if(voidparam != NULL)
{
*(voidparam + 1) = L')';
*(voidparam + 2) = 0;
}
}
pFunc->Release();
pFunc = NULL;
SysFreeString(file);
// find the line numbers touched by this address.
IDiaEnumLineNumbers *lines = NULL;
hr = modules[module - 1].pSession->findLinesByVA(addr, DWORD(4), &lines);
if(FAILED(hr))
{
if(lines)
lines->Release();
return ret;
}
IDiaLineNumber *line = NULL;
ULONG count = 0;
// just take the first one
if(SUCCEEDED(lines->Next(1, &line, &count)) && count == 1)
{
IDiaSourceFile *dia_source = NULL;
hr = line->get_sourceFile(&dia_source);
if(FAILED(hr))
{
line->Release();
lines->Release();
if(dia_source)
dia_source->Release();
return ret;
}
hr = dia_source->get_fileName(&file);
if(FAILED(hr))
{
line->Release();
lines->Release();
dia_source->Release();
return ret;
}
wcsncpy_s(ret.fileName, file, 126);
SysFreeString(file);
dia_source->Release();
dia_source = NULL;
DWORD line_num = 0;
hr = line->get_lineNumber(&line_num);
if(FAILED(hr))
{
line->Release();
lines->Release();
return ret;
}
ret.lineNum = line_num;
line->Release();
}
lines->Release();
}
return ret;
}
DWORD PE::AddSection(LPBYTE pBuffer,DWORD dwSize,PCHAR pszSectionName)
{
//修改文件头中的区段数量
m_pNt->FileHeader.NumberOfSections++;
//增加区段表项
memset(m_pLastSection,0,sizeof(IMAGE_SECTION_HEADER));
//写入区段名
strcpy_s((char*)m_pLastSection->Name,IMAGE_SIZEOF_SHORT_NAME,pszSectionName);
//区段虚拟大小
DWORD dwVirtualSize=0;
//区段文件大小
DWORD dwSizeOfRawData=0;
//把文件加载到内存所需要的大小
DWORD dwSizeOfImage=m_pNt->OptionalHeader.SizeOfImage;
//取余 查看内存是否对齐
if (dwSizeOfImage%m_dwMemAlign)
{
// 取商再原来基础上+1 比如说dwSizeOfImage=1726 对齐粒度m_dwMemAlign=200
//此时dwSizeOfImage=1800
dwSizeOfImage=(dwSizeOfImage/m_dwMemAlign+1)*m_dwMemAlign;
}
else
{
dwSizeOfImage=(dwSizeOfImage/m_dwMemAlign)*m_dwMemAlign;
}
//区段对齐后的RVA(dwSize) /内存对齐粒度 m_dwMemAlign
if (dwSize%m_dwMemAlign)
{
dwVirtualSize=(dwSize/m_dwMemAlign+1)*m_dwMemAlign;
}
else
{
dwVirtualSize=(dwSize/m_dwMemAlign)*m_dwMemAlign;
}
//区段对齐后的RVA(dwSize) /文件对齐粒度 m_dwMemAlign
if (dwSize%m_dwFileAlign)
{
dwSizeOfRawData=(dwSize/m_dwFileAlign+1)*m_dwFileAlign;
}
else
{
dwSizeOfRawData=(dwSize/m_dwFileAlign)*m_dwFileAlign;
}
//获取到新的相对虚拟地址 RVA
m_pLastSection->VirtualAddress=(m_pLastSection[-1].VirtualAddress+(dwSize/m_dwMemAlign)*m_dwMemAlign);
//区段在文件中的偏移
m_pLastSection->PointerToRawData=m_dwFileSize;
//区段在文件中大小
m_pLastSection->SizeOfRawData=dwSizeOfRawData;
//区段在内存中大小
m_pLastSection->Misc.VirtualSize=dwVirtualSize;
//区段属性
m_pLastSection->Characteristics=0Xe0000040;
//增加 文件大小 创建文件 添加代码段 确定入口点
m_pNt->OptionalHeader.SizeOfImage=dwSizeOfImage+dwVirtualSize;
m_pNt->OptionalHeader.AddressOfEntryPoint=m_dwNewOEP+m_pLastSection->VirtualAddress;
//生成输出文件路径
CString strPath=m_objFIle.GetFilePath();
TCHAR SzOutPath[MAX_PATH]={0};
//获取文件后缀名
LPWSTR strSuffix=PathFindExtension(strPath);
//目标文件路径到SzOutPath
wcsncpy_s(SzOutPath,MAX_PATH,strPath,wcslen(strPath));
//移除后缀名
PathRemoveExtension(SzOutPath);
// 在路径最后附加“_1”
wcscat_s(SzOutPath,MAX_PATH,L"_1");
// 在路径最后附加刚刚保存的后缀名
wcscat_s(SzOutPath, MAX_PATH, strSuffix);
//创建文件
CFile objFile(SzOutPath,CFile::modeCreate|CFile::modeReadWrite);
objFile.Write(m_pFileBase,(DWORD)m_objFIle.GetLength());
//移到文件尾
objFile.SeekToEnd();
//将pBuffer 按照大小dwSize 写入文件
objFile.Write(pBuffer,dwSize);
//返回操作完成后的最后一个区段的相对虚拟地址 RAV
return m_pLastSection->VirtualAddress;
}
static LRESULT CALLBACK MainWndSubclassProc(
_In_ HWND hWnd,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam,
_In_ UINT_PTR uIdSubclass,
_In_ ULONG_PTR dwRefData
)
{
if (uMsg == TaskbarButtonCreatedMsgId)
{
if (!TaskbarButtonsCreated)
{
BlackIcon = PhGetBlackIcon();
ButtonsImageList = ImageList_Create(16, 16, ILC_COLOR32 | ILC_MASK, 0, 0);
ImageList_SetImageCount(ButtonsImageList, 4);
PhSetImageListBitmap(ButtonsImageList, 0, PluginInstance->DllBase, MAKEINTRESOURCE(IDB_CHART_LINE_BMP));
PhSetImageListBitmap(ButtonsImageList, 1, PluginInstance->DllBase, MAKEINTRESOURCE(IDB_FIND_BMP));
PhSetImageListBitmap(ButtonsImageList, 2, PluginInstance->DllBase, MAKEINTRESOURCE(IDB_APPLICATION_BMP));
PhSetImageListBitmap(ButtonsImageList, 3, PluginInstance->DllBase, MAKEINTRESOURCE(IDB_APPLICATION_GO_BMP));
ButtonsArray[0].dwMask = THB_FLAGS | THB_BITMAP | THB_TOOLTIP;
ButtonsArray[0].dwFlags = THBF_ENABLED | THBF_DISMISSONCLICK;
ButtonsArray[0].iId = PHAPP_ID_VIEW_SYSTEMINFORMATION;
ButtonsArray[0].iBitmap = 0;
wcsncpy_s(ButtonsArray[0].szTip, ARRAYSIZE(ButtonsArray[0].szTip), L"System Information", _TRUNCATE);
ButtonsArray[1].dwMask = THB_FLAGS | THB_BITMAP | THB_TOOLTIP;
ButtonsArray[1].dwFlags = THBF_ENABLED | THBF_DISMISSONCLICK;
ButtonsArray[1].iId = PHAPP_ID_HACKER_FINDHANDLESORDLLS;
ButtonsArray[1].iBitmap = 1;
wcsncpy_s(ButtonsArray[1].szTip, ARRAYSIZE(ButtonsArray[1].szTip), L"Find Handles or DLLs", _TRUNCATE);
ButtonsArray[2].dwMask = THB_FLAGS | THB_BITMAP | THB_TOOLTIP;
ButtonsArray[2].dwFlags = THBF_ENABLED | THBF_DISMISSONCLICK;
ButtonsArray[2].iId = PHAPP_ID_HELP_LOG;
ButtonsArray[2].iBitmap = 2;
wcsncpy_s(ButtonsArray[2].szTip, ARRAYSIZE(ButtonsArray[2].szTip), L"Application Log", _TRUNCATE);
ButtonsArray[3].dwMask = THB_FLAGS | THB_BITMAP | THB_TOOLTIP;
ButtonsArray[3].dwFlags = THBF_ENABLED | THBF_DISMISSONCLICK;
ButtonsArray[3].iId = PHAPP_ID_TOOLS_INSPECTEXECUTABLEFILE;
ButtonsArray[3].iBitmap = 3;
wcsncpy_s(ButtonsArray[3].szTip, ARRAYSIZE(ButtonsArray[3].szTip), L"Inspect Executable File", _TRUNCATE);
TaskbarButtonsCreated = TRUE;
}
if (TaskbarListClass)
{
// Set the ThumbBar image list
ITaskbarList3_ThumbBarSetImageList(TaskbarListClass, PhMainWndHandle, ButtonsImageList);
// Set the ThumbBar buttons array
ITaskbarList3_ThumbBarAddButtons(TaskbarListClass, PhMainWndHandle, ARRAYSIZE(ButtonsArray), ButtonsArray);
if (TaskbarIconType != TASKBAR_ICON_NONE)
{
// Set the initial ThumbBar icon
ITaskbarList3_SetOverlayIcon(TaskbarListClass, PhMainWndHandle, BlackIcon, NULL);
}
}
}
return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}
// 处理过程
BOOL CSDMdlAttrParaSpecifiedValueCheck::DoAction(void *pData, const CheckData &checkData)
{
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
return FALSE;
ProModelitem mdlItem;
ProMdlToModelitem(pMdl, &mdlItem);
CStringArray arrItems;
CStringToCStringArray(checkData.checkRule.arrRuleContent[0], arrItems, L";");
ErrorItemArray arr;
CStringArray arrFailedPara; // 修复失败的参数列表
arr.Copy(checkData.checkResult.arrErrorItems);
for (int i=0, nIndex=0; i<arr.GetCount(); i++)
{
// 获取参数类型和是否指定
int nParaType;
BOOL bDesignation;
CString strParaValue;
nIndex = arr[i].nID;
int nCount = arrItems[nIndex].Find(L")") - arrItems[nIndex].Find(L"(")-1;
CString strProperty;
strProperty = arrItems[nIndex].Mid(arrItems[nIndex].Find(L"(") + 1, nCount);
CStringArray arrPropertys;
CStringToCStringArray(strProperty, arrPropertys, L",");
nParaType = _wtoi(arrPropertys[0]);
strParaValue = arrPropertys[1];
ParseParaValue(mdlItem, strParaValue, strParaValue);
bDesignation = _wtoi(arrPropertys[1]);
// 如果类型不匹配，先删除原参数
if(arr[i].nType == PARAERROR_TYPE)
{
if (!DelSDParameter(&mdlItem, arr[i].strItemName, FALSE))
{
arrFailedPara.Add(arr[i].strItemName);
continue;
}
}
else if (arr[i].nType == PARAERROR_DESIGNATION)
{
GetSDParameter(&mdlItem, arr[i].strItemName, strParaValue, FALSE);
}
// 创建参数
if (PARAM_STRING == nParaType)
{
if (!SetSDParameter(&mdlItem, arr[i].strItemName, strParaValue, FALSE))
{
arrFailedPara.Add(arr[i].strItemName);
continue;
}
}
else if (PARAM_REAL == nParaType)
{
double dVal = _wtof(strParaValue);
if (!SetSDParameter(&mdlItem, arr[i].strItemName, dVal, FALSE))
{
arrFailedPara.Add(arr[i].strItemName);
continue;
}
}
else if (PARAM_INTEGER == nParaType)
{
int nVal = _wtoi(strParaValue);
if (!SetSDParameter(&mdlItem, arr[i].strItemName, nVal, FALSE))
{
arrFailedPara.Add(arr[i].strItemName);
continue;
}
}
else if (PARAM_BOOL == nParaType)
{
ProBoolean bVal;
if (_wtoi(strParaValue) == 0)
bVal = PRO_B_FALSE;
else
bVal = PRO_B_TRUE;
if (!SetSDParameter(&mdlItem, arr[i].strItemName, bVal, FALSE))
{
arrFailedPara.Add(arr[i].strItemName);
continue;
}
}
// 修改指定关系
ProName paraname;
wcsncpy_s(paraname, PRO_NAME_SIZE, (LPCTSTR)arr[i].strItemName, _TRUNCATE);
ProParameter para;
if (GetSDParameter(&mdlItem, paraname, para))
{
if (bDesignation)
{
ProParameterDesignationAdd(¶);
}
else
ProParameterDesignationRemove(¶);
}
}
if (arrFailedPara.GetCount() > 0)
{
CString strResult;
strResult.Format(L"%s等%d个参数修复失败，请手动修复", arrFailedPara[0], arrFailedPara.GetCount());
MessageBox(NULL, strResult, L"提示", MB_OK|MB_ICONINFORMATION);
return FALSE;
}
return TRUE;
}
bool InstallService(PWSTR pszServiceName,
PWSTR pszDisplayName,
DWORD dwStartType,
PWSTR pszDependencies,
PWSTR pszAccount,
PWSTR pszPassword)
{
UninstallService(pszServiceName);
//std::ofstream file("c:\\users\\slee\\desktop\\text.txt", std::ios::app);
wchar_t szPath[MAX_PATH];
bool ret = false;
if (GetModuleFileName(NULL, szPath, ARRAYSIZE(szPath)) == 0) {
//file << "GetModuleFileName failed w/err " << GetLastError() << std::endl;
//wprintf(L"GetModuleFileName failed w/err 0x%08lx\n", GetLastError());
return false;
}
std::wstring tmp(szPath);
tmp = L"\"" + tmp + L"\"";
wcsncpy_s(szPath, tmp.c_str(), tmp.size()+1);
auto schSCManager = RAIISC_HANDLE(OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE));
if (schSCManager.get() == nullptr) {
//file << "OpenSCManager failed w/err " << GetLastError() << std::endl;
//wprintf(L"OpenSCManager failed w/err 0x%08lx\n", GetLastError());
}
else {
wcscat_s(szPath, L" -service_mon");
// Install the service into SCM by calling CreateService
auto schService = RAIISC_HANDLE(CreateService(
schSCManager.get(), // SCManager database
pszServiceName, // Name of service
pszDisplayName, // Name to display
SERVICE_ALL_ACCESS, // Desired access
SERVICE_WIN32_OWN_PROCESS, // Service type
dwStartType, // Service start type
SERVICE_ERROR_NORMAL, // Error control type
szPath, // Service's binary
NULL, // No load ordering group
NULL, // No tag identifier
pszDependencies, // Dependencies
pszAccount, // Service running account
pszPassword // Password of the account
));
if (schService.get() == nullptr){
/* file << "CreateService failed w/err " << GetLastError() << std::endl;
DEBUG_MSG("CreateService failed w / err %", GetLastError());*/
return false;
}
else {
// RemoteDesktop::EventLog::WriteLog(L"Service Installed " + std::wstring(pszServiceName), RemoteDesktop::EventLog::EventType::INFORMATIONAL, RemoteDesktop::EventLog::EventCategory::NETWORK_CATEGORY, RemoteDesktop::EventLog::EventID::SERVICE);
// file << "Service is installed" << std::endl;
//wprintf(L"%s is installed.\n", pszServiceName);
SERVICE_STATUS_PROCESS ssStatus;
DWORD dwOldCheckPoint;
DWORD dwStartTickCount;
DWORD dwWaitTime;
DWORD dwBytesNeeded;
// Check the status in case the service is not stopped.
if (!QueryServiceStatusEx(
schService.get(), // handle to service
SC_STATUS_PROCESS_INFO, // information level
(LPBYTE)&ssStatus, // address of structure
sizeof(SERVICE_STATUS_PROCESS), // size of structure
&dwBytesNeeded)) // size needed if buffer is too small
{
//printf("QueryServiceStatusEx failed (%d)\n", GetLastError());
return false;
}
// Check if the service is already running. It would be possible
// to stop the service here, but for simplicity this example just returns.
if (ssStatus.dwCurrentState != SERVICE_STOPPED && ssStatus.dwCurrentState != SERVICE_STOP_PENDING)
{
//printf("Cannot start the service because it is already running\n");
return false;
}
// Save the tick count and initial checkpoint.
dwStartTickCount = GetTickCount();
dwOldCheckPoint = ssStatus.dwCheckPoint;
// Wait for the service to stop before attempting to start it.
while (ssStatus.dwCurrentState == SERVICE_STOP_PENDING)
{
// Do not wait longer than the wait hint. A good interval is
// one-tenth of the wait hint but not less than 1 second
// and not more than 10 seconds.
dwWaitTime = ssStatus.dwWaitHint / 10;
if (dwWaitTime < 1000)
dwWaitTime = 1000;
else if (dwWaitTime > 10000)
dwWaitTime = 10000;
Sleep(dwWaitTime);
// Check the status until the service is no longer stop pending.
if (!QueryServiceStatusEx(
schService.get(), // handle to service
SC_STATUS_PROCESS_INFO, // information level
(LPBYTE)&ssStatus, // address of structure
sizeof(SERVICE_STATUS_PROCESS), // size of structure
&dwBytesNeeded)) // size needed if buffer is too small
{
//printf("QueryServiceStatusEx failed (%d)\n", GetLastError());
return false;
}
if (ssStatus.dwCheckPoint > dwOldCheckPoint)
{
// Continue to wait and check.
dwStartTickCount = GetTickCount();
dwOldCheckPoint = ssStatus.dwCheckPoint;
}
else
{
if (GetTickCount() - dwStartTickCount > ssStatus.dwWaitHint)
{
//printf("Timeout waiting for service to stop\n");
return false;
}
}
}
// Attempt to start the service.
if (!StartService( schService.get(), 0, NULL))
{
//printf("StartService failed (%d)\n", GetLastError());
return false;
}
// else printf("Service start pending...\n");
// Check the status until the service is no longer start pending.
if (!QueryServiceStatusEx(
schService.get(), // handle to service
SC_STATUS_PROCESS_INFO, // info level
(LPBYTE)&ssStatus, // address of structure
sizeof(SERVICE_STATUS_PROCESS), // size of structure
&dwBytesNeeded)) // if buffer too small
{
//printf("QueryServiceStatusEx failed (%d)\n", GetLastError());
return false;
}
// Save the tick count and initial checkpoint.
dwStartTickCount = GetTickCount();
dwOldCheckPoint = ssStatus.dwCheckPoint;
while (ssStatus.dwCurrentState == SERVICE_START_PENDING)
{
// Do not wait longer than the wait hint. A good interval is
// one-tenth the wait hint, but no less than 1 second and no
// more than 10 seconds.
dwWaitTime = ssStatus.dwWaitHint / 10;
if (dwWaitTime < 1000)
dwWaitTime = 1000;
else if (dwWaitTime > 10000)
dwWaitTime = 10000;
Sleep(dwWaitTime);
// Check the status again.
if (!QueryServiceStatusEx(
schService.get(), // handle to service
SC_STATUS_PROCESS_INFO, // info level
(LPBYTE)&ssStatus, // address of structure
sizeof(SERVICE_STATUS_PROCESS), // size of structure
&dwBytesNeeded)) // if buffer too small
{
//printf("QueryServiceStatusEx failed (%d)\n", GetLastError());
break;
}
if (ssStatus.dwCheckPoint > dwOldCheckPoint)
{
// Continue to wait and check.
dwStartTickCount = GetTickCount();
dwOldCheckPoint = ssStatus.dwCheckPoint;
}
else
{
if (GetTickCount() - dwStartTickCount > ssStatus.dwWaitHint)
{
// No progress made within the wait hint.
break;
}
}
}
// Determine whether the service is running.
if (ssStatus.dwCurrentState == SERVICE_RUNNING)
{
//printf("Service started successfully.\n");
return true;
}
else
{
/* printf("Service not started. \n");
printf(" Current State: %d\n", ssStatus.dwCurrentState);
printf(" Exit Code: %d\n", ssStatus.dwWin32ExitCode);
printf(" Check Point: %d\n", ssStatus.dwCheckPoint);
printf(" Wait Hint: %d\n", ssStatus.dwWaitHint);*/
return false;
}
//return StartService(schService.get(), 0, NULL) == TRUE;
}
}
return false;
}
// 检查开始
int CSDMdlAttrParaSpecifiedValueCheck::CheckAction(void *pData, const CheckRule &checkRule, CheckResult &checkResult)
{
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
if (!IsMdlTypeValid(pMdl, checkRule.dwMdlFilter))
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 模型是否符合过滤器要求
if (!IsFilterValid(checkRule.strRuleName, pMdl))
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 检查输入值有效性
if (checkRule.arrRuleContent.GetCount() < 1)
{
checkResult.nResultType = CHECK_RESULT_INVALID_INPUT;
return checkResult.nResultType;
}
//-----------------------------------------------------------------------------------
ProModelitem mdlItem;
ProMdlToModelitem(pMdl, &mdlItem);
checkResult.arrErrorItems.RemoveAll();
// 解析参数
CStringArray arrItems;
CStringToCStringArray(checkRule.arrRuleContent[0], arrItems, L";");
CString strParaName;
int nParaType;
CString strParaValue;
BOOL bDesignation;
for (int i = 0; i < arrItems.GetSize(); i ++)
{
strParaName = arrItems[i].Left(arrItems[i].Find(L"("));
int nCount = arrItems[i].Find(L")") - arrItems[i].Find(L"(")-1;
CString strProperty;
strProperty = arrItems[i].Mid(arrItems[i].Find(L"(") + 1, nCount);
CStringArray arrPropertys;
CStringToCStringArray(strProperty, arrPropertys, L",");
nParaType = _wtoi(arrPropertys[0]);
strParaValue = arrPropertys[1];
ParseParaValue(mdlItem, strParaValue, strParaValue);
bDesignation = _wtoi(arrPropertys[2]);
ProName paraname;
wcsncpy_s(paraname, PRO_NAME_SIZE, (LPCTSTR)strParaName, _TRUNCATE);
ProParameter para;
// 判断参数是否存在
ErrorItem item;
item.strItemName = strParaName;
item.nID = i;
if (GetSDParameter(&mdlItem, paraname, para))
{
// 检查参数类型
ProParamvalue proval;
ProParameterValueGet(¶, &proval);
int nType = GetParaType(proval.type);
if (nType != nParaType)
{
item.nType = PARAERROR_TYPE;
checkResult.arrErrorItems.Add(item);
}
else
{
// 检查参数值
if (PARAM_STRING == nParaType)
{
if (strParaValue.Compare(proval.value.s_val) != 0)
{
item.nType = PARAERROR_VALUE;
checkResult.arrErrorItems.Add(item);
continue;
}
}
else if (PARAM_REAL == nParaType)
{
if (!DEQUAL(proval.value.d_val, _wtof(strParaValue)))
{
item.nType = PARAERROR_VALUE;
checkResult.arrErrorItems.Add(item);
continue;
}
}
else if (PARAM_INTEGER == nParaType)
{
if (proval.value.i_val != _wtoi(strParaValue))
{
item.nType = PARAERROR_VALUE;
checkResult.arrErrorItems.Add(item);
continue;
}
}
else if (PARAM_BOOL == nParaType)
{
if (proval.value.l_val != _wtoi(strParaValue))
{
item.nType = PARAERROR_VALUE;
checkResult.arrErrorItems.Add(item);
continue;
}
}
// 检查是否指定
ProBoolean designation;
ProParameterDesignationVerify(¶, &designation);
if (bDesignation != designation)
{
item.nType = PARAERROR_DESIGNATION;
checkResult.arrErrorItems.Add(item);
}
}
}
else
{
item.nType = PARAERROR_NOEXIST;
checkResult.arrErrorItems.Add(item);
}
}
if (checkResult.arrErrorItems.GetCount() > 0)
checkResult.nResultType = CHECK_RESULT_ERROR_VALUE;
else
checkResult.nResultType = CHECK_RESULT_NO_ERROR;
return checkResult.nResultType;
}
BOOL CALLBACK MsdDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam) {
int port;
static wchar_t buff[4096] = { 0 };
switch (uMsg) {
case WM_INITDIALOG:
{
memset(buff, 0, sizeof(buff));
port = (int)lParam;
SetWindowLong(hW, GWL_USERDATA, (LONG)lParam);
CONFIGVARIANT var(N_CONFIG_PATH, CONFIG_TYPE_WCHAR);
if (LoadSetting(port, APINAME, var))
wcsncpy_s(buff, var.wstrValue.c_str(), ARRAYSIZE(buff));
SetWindowTextW(GetDlgItem(hW, IDC_EDIT1), buff);
return TRUE;
}
case WM_CREATE:
SetWindowLong(hW, GWL_USERDATA, (LONG)lParam);
break;
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED) {
switch (LOWORD(wParam)) {
case IDC_BUTTON1:
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hW;
ofn.lpstrTitle = L"USB image file";
ofn.lpstrFile = buff;
ofn.nMaxFile = ARRAYSIZE(buff);
ofn.lpstrFilter = L"All\0*.*\0";
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR;
if (GetOpenFileName(&ofn) == TRUE) {
SetWindowText(GetDlgItem(hW, IDC_EDIT1), ofn.lpstrFile);
}
break;
case IDOK:
{
INT_PTR res = RESULT_OK;
GetWindowTextW(GetDlgItem(hW, IDC_EDIT1), buff, ARRAYSIZE(buff));
port = (int)GetWindowLong(hW, GWL_USERDATA);
CONFIGVARIANT var(N_CONFIG_PATH, CONFIG_TYPE_WCHAR);
var.wstrValue = buff;
if (!SaveSetting(port, APINAME, var))
res = RESULT_FAILED;
//strcpy_s(conf.usb_img, ofn.lpstrFile);
EndDialog(hW, res);
return TRUE;
}
case IDCANCEL:
EndDialog(hW, FALSE);
return TRUE;
}
}
}
return FALSE;
}
//-----------------------------------------------------------------------------
static void load_paths_to_watch(LPCTSTR path, HANDLE completion_port_h) {
//-----------------------------------------------------------------------------
FILE * stream_p;
wchar_t *get_result;
HANDLE create_result;
size_t line_len;
struct watch_entry **link_p;
struct watch_entry * next_p;
if (_wfopen_s(&stream_p, path, L"r, ccs=UTF-8")) {
_wfopen_s(&error_file, error_path, L"w");
_wcserror_s(error_buffer, ARRAYSIZE(error_buffer), errno);
fwprintf(
error_file,
L"_wfopen(%s) failed: (%d) %s\n",
path,
errno,
error_buffer
);
fclose(error_file);
ExitProcess(2);
}
link_p = &watch_entry_list_p;
while (1) {
// create a watch entry
next_p = (struct watch_entry *) HeapAlloc(
GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct watch_entry)
);
if (next_p == NULL){
report_error(L"HeapAlloc failed to allocate memory", GetLastError());
ExitProcess(200);
}
// read in the path to watch from config.txt
get_result = \
fgetws(full_file_name, ARRAYSIZE(full_file_name), stream_p);
if (NULL == get_result) {
if (0 == ferror(stream_p)) {
HeapFree(GetProcessHeap(), 0, next_p);
break;
}
_wfopen_s(&error_file, error_path, L"w");
_wcserror_s(
error_buffer, sizeof error_buffer/sizeof(wchar_t) , errno
);
fwprintf(
error_file,
L"fgetws(%s) failed: (%d) %s\n",
path,
errno,
error_buffer
);
fclose(error_file);
ExitProcess(2);
}
// clean out the newline, if there is one
line_len = wcslen(full_file_name);
if (line_len && full_file_name[line_len-1] == L'\n'){
full_file_name[line_len-1] = L'\0';
line_len--;
}
if (full_file_name[0] == L'\0')
continue;
next_p->dir_path_len = line_len;
next_p->dir_path = (wchar_t *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
(line_len + 1) * sizeof(wchar_t));
if (next_p->dir_path == NULL){
report_error(L"HeapAlloc failed to allocate memory", GetLastError());
ExitProcess(201);
}
wcsncpy_s(next_p->dir_path, line_len+1, full_file_name, line_len);
next_p->changes_buffer = (BYTE *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
CHANGES_BUFFER_SIZE);
if (next_p->changes_buffer == NULL){
report_error(L"HeapAlloc failed to allocate memory", GetLastError());
ExitProcess(202);
}
// 2020-09-05 dougfort -- we don't clean out trailing slash here
// because if they are backing up something like c:\\, we need
// the trailing slash. This will come back to bite us when we are
// checking for excludes
// open a file handle to watch the directory in overlapped mode
next_p->hDirectory = CreateFile(
next_p->dir_path,
FILE_LIST_DIRECTORY,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
NULL
);
// 2009-03-11 dougfort -- if we can't create this file,
// assume it is a top-level directory
// which no longer exists; so ignore it and move on.
if (INVALID_HANDLE_VALUE == next_p->hDirectory) {
report_error(L"CreateFile", GetLastError());
continue;
}
// add this file handle to the IO Complete port
create_result = CreateIoCompletionPort(
next_p->hDirectory, // FileHandle,
completion_port_h, // ExistingCompletionPort,
0, // CompletionKey,
0 // NumberOfConcurrentThreads
);
if (NULL == create_result) {
report_error(L"CreateIOCompletionPort (add)", GetLastError());
ExitProcess(102);
}
if (create_result != completion_port_h) {
ExitProcess(103);
}
start_watch(next_p);
// add this entry to the list
*link_p = next_p;
// point to the new entry's next pointer
link_p = &(*link_p)->next_p;
} // while(1)
fclose(stream_p);
} // load_paths_to_watch
