void* CResourceCompilerHelper::AsyncCallResourceCompiler(
const char* szFileName,
const char* szAdditionalSettings,
bool bMayShowWindow,
CResourceCompilerHelper::ERcExePath rcExePath,
bool bSilent,
bool bNoUserDialog,
const wchar_t* szWorkingDirectory,
const wchar_t* szRootPath)
{
// make command for execution
SettingsManagerHelpers::CFixedString<wchar_t, MAX_PATH*3> wRemoteCmdLine;
if (!szAdditionalSettings)
{
szAdditionalSettings = "";
}
wchar_t szRemoteDirectory[512];
{
wchar_t pathBuffer[512];
switch (rcExePath)
{
case eRcExePath_registry:
GetRootPathUtf16(true, SettingsManagerHelpers::CWCharBuffer(pathBuffer, sizeof(pathBuffer)));
break;
case eRcExePath_settingsManager:
GetRootPathUtf16(false, SettingsManagerHelpers::CWCharBuffer(pathBuffer, sizeof(pathBuffer)));
break;
case eRcExePath_currentFolder:
wcscpy(pathBuffer, L".");
break;
case eRcExePath_customPath:
wcscpy(pathBuffer, szRootPath);
break;
default:
return NULL;
}
if (!pathBuffer[0])
{
wcscpy(pathBuffer, L".");
}
swprintf_s(szRemoteDirectory, L"%s/Bin32/rc", pathBuffer);
}
if (!szFileName)
{
wRemoteCmdLine.appendAscii("\"");
wRemoteCmdLine.append(szRemoteDirectory);
wRemoteCmdLine.appendAscii("/rc.exe\" /userdialog=0 ");
wRemoteCmdLine.appendAscii(szAdditionalSettings);
}
else
{
wRemoteCmdLine.appendAscii("\"");
wRemoteCmdLine.append(szRemoteDirectory);
wRemoteCmdLine.appendAscii("/rc.exe\" \"");
wRemoteCmdLine.appendAscii(szFileName);
wRemoteCmdLine.appendAscii("\" ");
wRemoteCmdLine.appendAscii(bNoUserDialog ? "/userdialog=0 " : "/userdialog=1 ");
wRemoteCmdLine.appendAscii(szAdditionalSettings);
}
STARTUPINFOW si;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
si.dwX = 100;
si.dwY = 100;
si.dwFlags = STARTF_USEPOSITION;
PROCESS_INFORMATION pi;
ZeroMemory(&pi, sizeof(pi));
bool bShowWindow = false;
{
wchar_t buffer[20];
g_pSettingsManager->GetValueByRef("ShowWindow", SettingsManagerHelpers::CWCharBuffer(buffer, sizeof(buffer)));
bShowWindow = (wcscmp(buffer, L"true") == 0);
}
if (!CreateProcessW(
NULL, // No module name (use command line).
const_cast<wchar_t*>(wRemoteCmdLine.c_str()), // Command line.
NULL, // Process handle not inheritable.
NULL, // Thread handle not inheritable.
TRUE, // Set handle inheritance to TRUE.
(bMayShowWindow && bShowWindow) ? 0 : CREATE_NO_WINDOW, // creation flags.
NULL, // Use parent's environment block.
szWorkingDirectory?szWorkingDirectory:szRemoteDirectory, // Set starting directory.
&si, // Pointer to STARTUPINFO structure.
&pi )) // Pointer to PROCESS_INFORMATION structure.
{
if (!bSilent)
{
MessageBoxA(0, "ResourceCompiler was not found.\n\nPlease verify CryENGINE RootPath.", "Error", MB_ICONERROR|MB_OK);
}
return NULL;
}
return pi.hProcess;
}
// virtual
HRESULT CXMLControlsHandler::SetPathNodeValue(BSTR path, BSTR value)
{
if (!m_bAnimation)
{
long ncount;
m_viewGroup->GetSelectedCount(&ncount);
for (int i = 0; i < ncount; i++)
{
CComPtr<IESelectedElement> selectedElement;
m_viewGroup->GetSelectedElementN(i, &selectedElement);
CComPtr<IEElement> eElement;
selectedElement->get_eElement(&eElement);
CComPtr<ILDOMElement> domElement;
eElement->get_domElement(&domElement);
::SetPathNodeValue(domElement, path, value);
}
}
else
{
long ncount;
m_viewGroup->GetSelectedCount(&ncount);
for (int i = 0; i < ncount; i++)
{
CComPtr<IESelectedElement> selectedElement;
m_viewGroup->GetSelectedElementN(i, &selectedElement);
CComPtr<IEElement> eElement;
selectedElement->get_eElement(&eElement);
CComPtr<ILDOMElement> domElement;
eElement->get_domElement(&domElement);
CComBSTR attributeName;
domElement->getAttribute(L"attributeName", &attributeName);
if (!wcscmp(attributeName, &path[1]))
{
// ::SetPathNodeValue(domElement, path, value);
CComQIPtr<IESelectedAnimationElement> selectedAnimationElement = selectedElement;
//if (wcscmp(attributeName,
if (selectedAnimationElement)//TRUE) // TODO
{
//CComQIPtr<ILSMILAnimationTarget> animationTarget = animationTarget;
CComQIPtr<ILAnimateXXX> animateXXX = domElement;
long ncount;
selectedAnimationElement->GetSelectedKeyTimesCount(&ncount);
for (int i = 0; i < ncount; i++)
{
long keyFrame;
selectedAnimationElement->GetKeyTimeSelected(i, &keyFrame);
CComPtr<ILSMILAttributeValue> attributeValue;
animateXXX->GetValue(keyFrame, &attributeValue);
attributeValue->setStringValue(value);
}
}
}
}
}
return S_OK;
}
void CXMLControlsHandler::UpdateData(CXMLData* pData)
{
if (m_reentrancy == 0)
{
m_reentrancy++;
// long ncount;
// m_viewGroup->GetSelectedCount(&ncount);
CComBSTR value;
GetPathNodeValue(pData->m_name, &value);
#if 0
for (int i = 0; i < ncount; i++)
{
CComPtr<IESelectedElement> selectedElement;
m_viewGroup->GetSelectedElementN(i, &selectedElement);
CComPtr<IEElement> eElement;
selectedElement->get_eElement(&eElement);
CComPtr<ILDOMElement> domElement;
eElement->get_domElement(&domElement);
CComBSTR value2 = pData->GetDataValue(domElement);
if (i == 0)
{
value = value2;
}
else if (wcscmp(value, value2))
{
value.Empty();
break;
}
}
#endif
pData->SetValue(value);
m_reentrancy--;
}
#if 0
if (m_reentrancy == 0)
{
m_reentrancy++;
long ncount;
m_viewGroup->GetSelectedCount(&ncount);
CComBSTR value;
for (int i = 0; i < ncount; i++)
{
CComPtr<IESelectedElement> selectedElement;
m_viewGroup->GetSelectedElementN(i, &selectedElement);
CComPtr<IEElement> eElement;
selectedElement->get_eElement(&eElement);
CComPtr<ILDOMElement> domElement;
eElement->get_domElement(&domElement);
//CComBSTR value2 = pData->GetDataValue(domElement);
CComBSTR value2;
::GetPathNodeValue(domElement, pData->m_name, &value2);
if (i == 0)
{
value = value2;
}
else if (cmpbstr(value, value2))
{
value.Empty();
break;
}
}
pData->SetValue(value);
m_reentrancy--;
}
#endif
}
void wmain( int argc, wchar_t *argv[ ])
{
//Handle the command line arguments.
LPOLESTR pszBuffer = NULL;
pszBuffer = new OLECHAR[MAX_PATH*2];
if(pszBuffer == NULL)
goto ret;
if (argv[1] == NULL)
{
wprintf(L"This program finds a user in the current Window 2000 domain\n");
wprintf(L"and displays its objectSid property in string form.\n");
wprintf(L"This program demonstrates reading a property of type octet string.\n\n");
wprintf(L"Enter Common Name of the user to find:");
if ( !_getws_s(pszBuffer, MAX_PATH*2))
{
delete [] pszBuffer;
wprintf(L"String exceeded buffer size.\n\n");
return;
}
}
else
if ( !wcscpy_s(pszBuffer, MAX_PATH*2, argv[1]))
{
delete [] pszBuffer;
wprintf(L"String exceeded buffer size.\n\n");
return;
}
//if empty string, exit.
if (0==wcscmp(L"", pszBuffer))
goto ret;
wprintf(L"\nFinding user: %s...\n",pszBuffer);
//Intialize COM
CoInitialize(NULL);
HRESULT hr = S_OK;
//Get rootDSE and the domain container's DN.
IADs *pObject = NULL;
IDirectorySearch *pDS = NULL;
LPOLESTR szPath = NULL;
szPath = new OLECHAR[MAX_PATH];
if(szPath == NULL)
goto ret;
VARIANT var;
hr = ADsOpenObject(L"LDAP://rootDSE",
NULL,
NULL,
ADS_SECURE_AUTHENTICATION, //Use Secure Authentication
IID_IADs,
(void**)&pObject);
if (FAILED(hr))
{
wprintf(L"Not Found. Could not bind to the domain.\n");
if (pObject)
pObject->Release();
goto ret;
}
VariantInit(&var);
hr = pObject->Get(L"defaultNamingContext",&var);
if (SUCCEEDED(hr))
{
wcscpy_s(szPath,MAX_PATH,L"LDAP://");
wcscat_s(szPath,MAX_PATH,var.bstrVal);
VariantClear(&var);
if (pObject)
{
pObject->Release();
pObject = NULL;
}
//Bind to the root of the current domain.
hr = ADsOpenObject(szPath,
NULL,
NULL,
ADS_SECURE_AUTHENTICATION, //Use Secure Authentication
IID_IDirectorySearch,
(void**)&pDS);
if (SUCCEEDED(hr))
{
hr = FindUserByName(pDS, //Container to search
pszBuffer, //Name of user to find.
&pObject); //Return a pointer to the user
if (SUCCEEDED(hr))
{
//Get the objectSid property
hr = pObject->Get(L"objectSid", &var);
if (SUCCEEDED(hr))
{
LPBYTE pByte = NULL;
wprintf (L"----------------------------------------------\n");
wprintf (L"----------Call GetLPBYTEtoOctetString---------\n");
wprintf (L"----------------------------------------------\n");
hr = GetLPBYTEtoOctetString(&var, //IN. Pointer to variant containing the octetstring.
&pByte //OUT. Return LPBYTE to the data represented in octetstring.
);
PSID pObjectSID = (PSID)pByte;
//Convert SID to string.
LPOLESTR szSID = NULL;
ConvertSidToStringSid(pObjectSID, &szSID);
wprintf(L"objectSid:%s\n",szSID);
LocalFree(szSID);
//Free the buffer.
CoTaskMemFree(pByte);
}
else
wprintf(L"Get method failed with hr: %x\n",hr);
VariantClear(&var);
}
else
{
wprintf(L"User \"%s\" not Found.\n",pszBuffer);
wprintf (L"FindUserByName failed with the following HR: %x\n", hr);
}
if (pObject)
pObject->Release();
}
if (pDS)
pDS->Release();
}
ret:
if(pszBuffer) delete pszBuffer;
if(szPath) delete szPath;
//Uninitalize COM
CoUninitialize();
return;
}
//-----------------------------------------------------------------------------
// Initliaze perf logging. Must be called before calling PERFLOG (x)...
void PerfLog::PerfLogInitialize()
{
LIMITED_METHOD_CONTRACT;
// Make sure we are called only once.
if (m_perfLogInit)
{
return;
}
// First check for special cases:
#if defined(ENABLE_JIT_PERF)
// Checks the JIT_PERF_OUTPUT env var and sets g_fJitPerfOn.
InitJitPerf();
#endif
#ifdef WS_PERF
// Private working set perf stats
InitWSPerf();
#endif // WS_PERF
// Put other special cases here.
// <TODO>@TODO agk: clean this logic a bit</TODO>
// Special cases considered. Now turn on loggin if any of above want logging
// or if PERF_OUTPUT says so.
wchar_t lpszValue[2];
// Read the env var PERF_OUTPUT and if set continue.
m_fLogPerfData = WszGetEnvironmentVariable (W("PERF_OUTPUT"), lpszValue, sizeof(lpszValue)/sizeof(lpszValue[0]));
#if defined(ENABLE_JIT_PERF)
if (!m_fLogPerfData)
{
// Make sure that JIT perf was not requested.
if (!g_fJitPerfOn)
return;
// JIT perf stats are needed so set the flags also.
m_fLogPerfData = 1;
}
#endif
// See if we want to output to the database
wchar_t _lpszValue[11];
DWORD _cchValue = 10; // 11 - 1
_cchValue = WszGetEnvironmentVariable (W("PerfOutput"), _lpszValue, _cchValue);
if (_cchValue && (wcscmp (_lpszValue, W("DBase")) == 0))
m_perfAutomationFormat = true;
if (_cchValue && (wcscmp (_lpszValue, W("CSV")) == 0))
m_commaSeparatedFormat = true;
if (PerfAutomationFormat() || CommaSeparatedFormat())
{
// Hardcoded file name for spitting the perf auotmation formatted perf data. Open
// the file here for writing and close in PerfLogDone().
m_hPerfLogFileHandle = WszCreateFile (
#ifdef PLATFORM_UNIX
L"/tmp/PerfData.dat",
#else
W("C:\\PerfData.dat"),
#endif
GENERIC_WRITE,
FILE_SHARE_WRITE,
0,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
0);
// check return value
if(m_hPerfLogFileHandle == INVALID_HANDLE_VALUE)
{
m_fLogPerfData = 0;
goto ErrExit;
}
// Make sure we append to the file. <TODO>@TODO agk: Is this necessary?</TODO>
if(SetFilePointer (m_hPerfLogFileHandle, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER )
{
CloseHandle (m_hPerfLogFileHandle);
m_fLogPerfData = 0;
goto ErrExit;
}
}
m_perfLogInit = true;
ErrExit:
return;
}
GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
{
return wcscmp(first->win32.displayName, second->win32.displayName) == 0;
}
static int winhttp_stream_read(
git_smart_subtransport_stream *stream,
char *buffer,
size_t buf_size,
size_t *bytes_read)
{
winhttp_stream *s = (winhttp_stream *)stream;
winhttp_subtransport *t = OWNING_SUBTRANSPORT(s);
DWORD dw_bytes_read;
char replay_count = 0;
int error;
replay:
/* Enforce a reasonable cap on the number of replays */
if (++replay_count >= 7) {
giterr_set(GITERR_NET, "Too many redirects or authentication replays");
return -1;
}
/* Connect if necessary */
if (!s->request && winhttp_stream_connect(s) < 0)
return -1;
if (!s->received_response) {
DWORD status_code, status_code_length, content_type_length, bytes_written;
char expected_content_type_8[MAX_CONTENT_TYPE_LEN];
wchar_t expected_content_type[MAX_CONTENT_TYPE_LEN], content_type[MAX_CONTENT_TYPE_LEN];
if (!s->sent_request) {
if ((error = send_request(s, s->post_body_len, 0)) < 0)
return error;
s->sent_request = 1;
}
if (s->chunked) {
assert(s->verb == post_verb);
/* Flush, if necessary */
if (s->chunk_buffer_len > 0 &&
write_chunk(s->request, s->chunk_buffer, s->chunk_buffer_len) < 0)
return -1;
s->chunk_buffer_len = 0;
/* Write the final chunk. */
if (!WinHttpWriteData(s->request,
"0\r\n\r\n", 5,
&bytes_written)) {
giterr_set(GITERR_OS, "Failed to write final chunk");
return -1;
}
}
else if (s->post_body) {
char *buffer;
DWORD len = s->post_body_len, bytes_read;
if (INVALID_SET_FILE_POINTER == SetFilePointer(s->post_body,
0, 0, FILE_BEGIN) &&
NO_ERROR != GetLastError()) {
giterr_set(GITERR_OS, "Failed to reset file pointer");
return -1;
}
buffer = git__malloc(CACHED_POST_BODY_BUF_SIZE);
while (len > 0) {
DWORD bytes_written;
if (!ReadFile(s->post_body, buffer,
min(CACHED_POST_BODY_BUF_SIZE, len),
&bytes_read, NULL) ||
!bytes_read) {
git__free(buffer);
giterr_set(GITERR_OS, "Failed to read from temp file");
return -1;
}
if (!WinHttpWriteData(s->request, buffer,
bytes_read, &bytes_written)) {
git__free(buffer);
giterr_set(GITERR_OS, "Failed to write data");
return -1;
}
len -= bytes_read;
assert(bytes_read == bytes_written);
}
git__free(buffer);
/* Eagerly close the temp file */
CloseHandle(s->post_body);
s->post_body = NULL;
}
if (!WinHttpReceiveResponse(s->request, 0)) {
giterr_set(GITERR_OS, "Failed to receive response");
return -1;
}
/* Verify that we got a 200 back */
status_code_length = sizeof(status_code);
if (!WinHttpQueryHeaders(s->request,
WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
WINHTTP_HEADER_NAME_BY_INDEX,
&status_code, &status_code_length,
WINHTTP_NO_HEADER_INDEX)) {
giterr_set(GITERR_OS, "Failed to retrieve status code");
return -1;
}
/* The implementation of WinHTTP prior to Windows 7 will not
* redirect to an identical URI. Some Git hosters use self-redirects
* as part of their DoS mitigation strategy. Check first to see if we
* have a redirect status code, and that we haven't already streamed
* a post body. (We can't replay a streamed POST.) */
if (!s->chunked &&
(HTTP_STATUS_MOVED == status_code ||
HTTP_STATUS_REDIRECT == status_code ||
(HTTP_STATUS_REDIRECT_METHOD == status_code &&
get_verb == s->verb) ||
HTTP_STATUS_REDIRECT_KEEP_VERB == status_code)) {
/* Check for Windows 7. This workaround is only necessary on
* Windows Vista and earlier. Windows 7 is version 6.1. */
wchar_t *location;
DWORD location_length;
char *location8;
/* OK, fetch the Location header from the redirect. */
if (WinHttpQueryHeaders(s->request,
WINHTTP_QUERY_LOCATION,
WINHTTP_HEADER_NAME_BY_INDEX,
WINHTTP_NO_OUTPUT_BUFFER,
&location_length,
WINHTTP_NO_HEADER_INDEX) ||
GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
giterr_set(GITERR_OS, "Failed to read Location header");
return -1;
}
location = git__malloc(location_length);
GITERR_CHECK_ALLOC(location);
if (!WinHttpQueryHeaders(s->request,
WINHTTP_QUERY_LOCATION,
WINHTTP_HEADER_NAME_BY_INDEX,
location,
&location_length,
WINHTTP_NO_HEADER_INDEX)) {
giterr_set(GITERR_OS, "Failed to read Location header");
git__free(location);
return -1;
}
/* Convert the Location header to UTF-8 */
if (git__utf16_to_8_alloc(&location8, location) < 0) {
giterr_set(GITERR_OS, "Failed to convert Location header to UTF-8");
git__free(location);
return -1;
}
git__free(location);
/* Replay the request */
winhttp_stream_close(s);
if (!git__prefixcmp_icase(location8, prefix_https)) {
/* Upgrade to secure connection; disconnect and start over */
if (gitno_connection_data_from_url(&t->connection_data, location8, s->service_url) < 0) {
git__free(location8);
return -1;
}
winhttp_close_connection(t);
if (winhttp_connect(t) < 0)
return -1;
}
git__free(location8);
goto replay;
}
/* Handle authentication failures */
if (HTTP_STATUS_DENIED == status_code && get_verb == s->verb) {
int allowed_types;
if (parse_unauthorized_response(s->request, &allowed_types, &t->auth_mechanism) < 0)
return -1;
if (allowed_types &&
(!t->cred || 0 == (t->cred->credtype & allowed_types))) {
int cred_error = 1;
/* Start with the user-supplied credential callback, if present */
if (t->owner->cred_acquire_cb) {
cred_error = t->owner->cred_acquire_cb(&t->cred, t->owner->url,
t->connection_data.user, allowed_types, t->owner->cred_acquire_payload);
if (cred_error < 0)
return cred_error;
}
/* Invoke the fallback credentials acquisition callback if necessary */
if (cred_error > 0) {
cred_error = fallback_cred_acquire_cb(&t->cred, t->owner->url,
t->connection_data.user, allowed_types, NULL);
if (cred_error < 0)
return cred_error;
}
if (!cred_error) {
assert(t->cred);
winhttp_stream_close(s);
/* Successfully acquired a credential */
goto replay;
}
}
}
if (HTTP_STATUS_OK != status_code) {
giterr_set(GITERR_NET, "Request failed with status code: %d", status_code);
return -1;
}
/* Verify that we got the correct content-type back */
if (post_verb == s->verb)
p_snprintf(expected_content_type_8, MAX_CONTENT_TYPE_LEN, "application/x-git-%s-result", s->service);
else
p_snprintf(expected_content_type_8, MAX_CONTENT_TYPE_LEN, "application/x-git-%s-advertisement", s->service);
if (git__utf8_to_16(expected_content_type, MAX_CONTENT_TYPE_LEN, expected_content_type_8) < 0) {
giterr_set(GITERR_OS, "Failed to convert expected content-type to wide characters");
return -1;
}
content_type_length = sizeof(content_type);
if (!WinHttpQueryHeaders(s->request,
WINHTTP_QUERY_CONTENT_TYPE,
WINHTTP_HEADER_NAME_BY_INDEX,
&content_type, &content_type_length,
WINHTTP_NO_HEADER_INDEX)) {
giterr_set(GITERR_OS, "Failed to retrieve response content-type");
return -1;
}
if (wcscmp(expected_content_type, content_type)) {
giterr_set(GITERR_NET, "Received unexpected content-type");
return -1;
}
s->received_response = 1;
}
if (!WinHttpReadData(s->request,
(LPVOID)buffer,
(DWORD)buf_size,
&dw_bytes_read))
{
giterr_set(GITERR_OS, "Failed to read data");
return -1;
}
*bytes_read = dw_bytes_read;
return 0;
}
void STDMETHODCALLTYPE IECrossfireBHO::OnDocumentComplete(IDispatch *pDisp, VARIANT *pvarURL) {
BSTR bstr = pvarURL->bstrVal;
if (bstr && m_htmlToDisplay && wcscmp(bstr, ABOUT_BLANK) == 0) {
CComPtr<IUnknown> webBrowserIUnknown = NULL;
HRESULT hr = m_webBrowser->QueryInterface(IID_IUnknown, (void**)&webBrowserIUnknown);
if (SUCCEEDED(hr)) {
CComPtr<IUnknown> pDispIUnknown = NULL;
hr = pDisp->QueryInterface(IID_IUnknown, (void**)&pDispIUnknown);
if (SUCCEEDED(hr)) {
if (webBrowserIUnknown == pDispIUnknown) {
/* this is the top-level page frame */
size_t length = (wcslen(m_htmlToDisplay) + 1) * 2;
HGLOBAL buffer = GlobalAlloc(GPTR, length);
if (buffer) {
wcscpy_s((wchar_t*)buffer, length, m_htmlToDisplay);
CComPtr<IStream> stream = NULL;
HRESULT hr = CreateStreamOnHGlobal(buffer, false, &stream);
if (SUCCEEDED(hr)) {
CComPtr<IDispatch> document = NULL;
HRESULT hr = m_webBrowser->get_Document(&document);
if (SUCCEEDED(hr)) {
CComPtr<IPersistStreamInit> persistStreamInit = NULL;
hr = document->QueryInterface(IID_IPersistStreamInit, (void**)&persistStreamInit);
if (SUCCEEDED(hr)) {
hr = persistStreamInit->InitNew();
if (SUCCEEDED(hr)) {
hr = persistStreamInit->Load(stream);
}
}
}
if (FAILED(hr)) {
Logger::error("IECrossfireBHO.OnDocumentComplete(): failed setting page content", hr);
}
} else {
Logger::error("IECrossfireBHO.OnDocumentComplete(): CreateStreamOnHGlobal() failed", hr);
}
GlobalFree(buffer);
}
free(m_htmlToDisplay);
m_htmlToDisplay = NULL;
}
}
}
if (FAILED(hr)) {
Logger::error("IECrossfireBHO.OnDocumentComplete() failed", hr);
}
return;
}
if (m_serverState != STATE_CONNECTED) {
return;
}
CComPtr<IUnknown> webBrowserIUnknown = NULL;
HRESULT hr = m_webBrowser->QueryInterface(IID_IUnknown, (void**)&webBrowserIUnknown);
if (FAILED(hr)) {
Logger::error("IECrossfireBHO.OnDocumentComplete(): QI(IUnknown)[1] failed", hr);
} else {
CComPtr<IUnknown> pDispIUnknown = NULL;
hr = pDisp->QueryInterface(IID_IUnknown, (void**)&pDispIUnknown);
if (FAILED(hr)) {
Logger::error("IECrossfireBHO.OnDocumentComplete(): QI(IUnknown)[2] failed", hr);
} else {
if (webBrowserIUnknown == pDispIUnknown) {
/* this is the top-level page frame */
HRESULT hr = m_server->contextLoaded(GetCurrentProcessId());
if (FAILED(hr)) {
Logger::error("IECrossfireBHO.OnDocumentComplete(): contextLoaded() failed", hr);
}
}
}
}
}
BOOL
bGetPrnModel(HANDLE hModule,
LPWSTR pPrinterModel,
PMOPIERDM* pmdmDefault,
PPRNPROPSHEET* pPrnPropSheet)
{
BOOL result = FALSE;
WCHAR matchedPrinterModel[MAX_RES_STR_CHARS];
TRY
ASSERT(pPrinterModel);
/* 1) If a valid printer model is given, try to match that first.
*/
if(pPrinterModel) {
if(OEMLoadString(hModule, IDS_CUI_JONAH_VER, matchedPrinterModel, MAX_RES_STR_CHARS))
if(wcscmp(pPrinterModel, matchedPrinterModel) == 0) {
if(pmdmDefault) {
*pmdmDefault = &JonahDM;
result = TRUE;
}
if(pPrnPropSheet) {
*pPrnPropSheet = &JonahSheet;
#ifdef UI
result = bFillMBwResources(hModule, *pPrnPropSheet);
#else
result = TRUE;
#endif /* UI */
}
LEAVE;
}
if(OEMLoadString(hModule, IDS_CUI_SI_VER, matchedPrinterModel, MAX_RES_STR_CHARS))
if(wcscmp(pPrinterModel, matchedPrinterModel) == 0) {
if(pmdmDefault) {
*pmdmDefault = &EclipseDM;
result = TRUE;
}
if(pPrnPropSheet) {
*pPrnPropSheet = &EclipseSheet;
#ifdef UI
result = bFillMBwResources(hModule, *pPrnPropSheet);
#else
result = TRUE;
#endif /* UI */
}
LEAVE;
}
if(OEMLoadString(hModule, IDS_CUI_ECLIPSE_VER, matchedPrinterModel, MAX_RES_STR_CHARS))
if(wcscmp(pPrinterModel, matchedPrinterModel) == 0) {
if(pmdmDefault) {
*pmdmDefault = &SiDM;
result = TRUE;
}
if(pPrnPropSheet) {
*pPrnPropSheet = &SiSheet;
#ifdef UI
result = bFillMBwResources(hModule, *pPrnPropSheet);
#else
result = TRUE;
#endif /* UI */
}
LEAVE;
}
}
ENDTRY
FINALLY
ENDFINALLY
return result;
}
int main(int argc, char** argv)
{
HeapInitialize();
for (int i=0; i<argc; i++)
{
if (strcmp(argv[i], "-verbose")==0 || strcmp(argv[i], "--verbose")==0)
gbVerifyVerbose = true;
}
// Tests
{
Verify_Step("ls1(`Test`)");
CEStr ls1(L"Test");
Verify0((ls1.ms_Val && 0==wcscmp(ls1.ms_Val,L"Test")),"ls1==`Test`");
Verify_Step("ls12 = ls1.Detach()");
/* Store ptr for Verify test result */ LPCWSTR pszPtr = ls1.ms_Val;
CEStr ls2 = ls1.Detach();
Verify2((ls2.ms_Val && !ls1.ms_Val && ls2.ms_Val==pszPtr),"ls2.ms_Val{x%p}==pszPtr{x%p}",ls2.ms_Val,pszPtr);
}
{
Verify_Step("ls3 = `Test3`");
CEStr ls3 = L"Test3";
Verify0((ls3.ms_Val && 0==wcscmp(ls3.ms_Val,L"Test3")),"ls3==`Test3`");
Verify_Step("ls4 = (LPCWSTR)ls3.ms_Val");
CEStr ls4 = static_cast<LPCWSTR>(ls3.ms_Val);
Verify2((ls4.ms_Val && ls4.ms_Val != ls3.ms_Val),"ls4.ms_Val{x%p}!=ls3.ms_Val{x%p}",ls4.ms_Val,ls3.ms_Val);
Verify_Step("ls5 = lstrdup(ls3)");
CEStr ls5 = lstrdup(ls3);
Verify0((ls5.ms_Val && 0==wcscmp(ls5.ms_Val,L"Test3")),"ls5==`Test3`");
Verify_Step("ls6(lstrdup(ls3))");
CEStr ls6(lstrdup(ls3));
Verify0((ls6.ms_Val && 0==wcscmp(ls6.ms_Val,L"Test3")),"ls6==`Test3`");
}
{
Verify_Step("-new_console parser tests");
LPCWSTR pszTest = L"-new_console:a \\\"-new_console:c\\\" `-new_console:d:C:\\` -cur_console:b";
LPCWSTR pszCmp = L"\\\"-new_console:c\\\" `-new_console:d:C:\\`";
RConStartArgs arg; arg.pszSpecialCmd = lstrdup(pszTest);
arg.ProcessNewConArg();
int iCmp = lstrcmp(arg.pszSpecialCmd, pszCmp);
Verify0((iCmp==0),"arg.pszSpecialCmd==\\\"-new_console:c\\\" `-new_console:d:C:\\`");
Verify_Step("RConStartArgs::RunArgTests()");
RConStartArgs::RunArgTests();
Verify0(!gbVerifyFailed,"RConStartArgs tests passed");
}
{
Verify_Step("msprintf tests");
wchar_t szBuffer[200];
msprintf(szBuffer, countof(szBuffer), L"%u %03u %03u %i %x %02X %02X %04x %08X",
123, 98, 4567, -234, 0x12AB, 0x0A, 0xABC, 0x01A0, 0x0765ABCD);
const wchar_t szStd[] = L"123 098 4567 -234 12ab 0A ABC 01a0 0765ABCD";
int iCmp = lstrcmp(szBuffer, szStd);
WVerify2((iCmp==0),L"`%s` (msprintf[W])\n `%s` (standard)", szBuffer, szStd);
char szBufA[200];
msprintf(szBufA, countof(szBufA), "%u %i %x %02X %02X %04x %08X",
123, -234, 0x12AB, 0x0A, 0xABC, 0x01A0, 0x0765ABCD);
const char szStdA[] = "123 -234 12ab 0A ABC 01a0 0765ABCD";
iCmp = lstrcmpA(szBufA, szStdA);
Verify2((iCmp==0),"`%s` (msprintf[A])\n `%s` (standard)", szBufA, szStdA);
}
if (gbVerifyFailed)
Verify_MsgFail("Some tests failed!");
else
Verify_MsgOk("All done");
return gbVerifyFailed ? 99 : 0;
}
int test_implicit_compare_with_functions() {
if (memcmp(A, "a", 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'memcmp' is called without explicitly comparing result
// CHECK-FIXES: memcmp(A, "a", 1) != 0)
if (wmemcmp(W, L"a", 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'wmemcmp' is called without explicitly comparing result
// CHECK-FIXES: wmemcmp(W, L"a", 1) != 0)
if (memicmp(A, "a", 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'memicmp' is called without explicitly comparing result
// CHECK-FIXES: memicmp(A, "a", 1) != 0)
if (_memicmp(A, "a", 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_memicmp' is called without explicitly comparing result
// CHECK-FIXES: _memicmp(A, "a", 1) != 0)
if (_memicmp_l(A, "a", 1, locale))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_memicmp_l' is called without explicitly comparing result
// CHECK-FIXES: _memicmp_l(A, "a", 1, locale) != 0)
if (strcmp(A, "a"))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'strcmp' is called without explicitly comparing result
// CHECK-FIXES: strcmp(A, "a") != 0)
if (strncmp(A, "a", 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'strncmp' is called without explicitly comparing result
// CHECK-FIXES: strncmp(A, "a", 1) != 0)
if (strcasecmp(A, "a"))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'strcasecmp' is called without explicitly comparing result
// CHECK-FIXES: strcasecmp(A, "a") != 0)
if (strncasecmp(A, "a", 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'strncasecmp' is called without explicitly comparing result
// CHECK-FIXES: strncasecmp(A, "a", 1) != 0)
if (stricmp(A, "a"))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'stricmp' is called without explicitly comparing result
// CHECK-FIXES: stricmp(A, "a") != 0)
if (strcmpi(A, "a"))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'strcmpi' is called without explicitly comparing result
// CHECK-FIXES: strcmpi(A, "a") != 0)
if (_stricmp(A, "a"))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_stricmp' is called without explicitly comparing result
// CHECK-FIXES: _stricmp(A, "a") != 0)
if (strnicmp(A, "a", 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'strnicmp' is called without explicitly comparing result
// CHECK-FIXES: strnicmp(A, "a", 1) != 0)
if (_strnicmp(A, "a", 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_strnicmp' is called without explicitly comparing result
// CHECK-FIXES: _strnicmp(A, "a", 1) != 0)
if (_stricmp_l(A, "a", locale))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_stricmp_l' is called without explicitly comparing result
// CHECK-FIXES: _stricmp_l(A, "a", locale) != 0)
if (_strnicmp_l(A, "a", 1, locale))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_strnicmp_l' is called without explicitly comparing result
// CHECK-FIXES: _strnicmp_l(A, "a", 1, locale) != 0)
if (wcscmp(W, L"a"))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'wcscmp' is called without explicitly comparing result
// CHECK-FIXES: wcscmp(W, L"a") != 0)
if (wcsncmp(W, L"a", 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'wcsncmp' is called without explicitly comparing result
// CHECK-FIXES: wcsncmp(W, L"a", 1) != 0)
if (wcscasecmp(W, L"a"))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'wcscasecmp' is called without explicitly comparing result
// CHECK-FIXES: wcscasecmp(W, L"a") != 0)
if (wcsicmp(W, L"a"))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'wcsicmp' is called without explicitly comparing result
// CHECK-FIXES: wcsicmp(W, L"a") != 0)
if (_wcsicmp(W, L"a"))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_wcsicmp' is called without explicitly comparing result
// CHECK-FIXES: _wcsicmp(W, L"a") != 0)
if (_wcsicmp_l(W, L"a", locale))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_wcsicmp_l' is called without explicitly comparing result
// CHECK-FIXES: _wcsicmp_l(W, L"a", locale) != 0)
if (wcsnicmp(W, L"a", 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function 'wcsnicmp' is called without explicitly comparing result
// CHECK-FIXES: wcsnicmp(W, L"a", 1) != 0)
if (_wcsnicmp(W, L"a", 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_wcsnicmp' is called without explicitly comparing result
// CHECK-FIXES: _wcsnicmp(W, L"a", 1) != 0)
if (_wcsnicmp_l(W, L"a", 1, locale))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_wcsnicmp_l' is called without explicitly comparing result
// CHECK-FIXES: _wcsnicmp_l(W, L"a", 1, locale) != 0)
if (_mbscmp(U, V))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_mbscmp' is called without explicitly comparing result
// CHECK-FIXES: _mbscmp(U, V) != 0)
if (_mbsncmp(U, V, 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_mbsncmp' is called without explicitly comparing result
// CHECK-FIXES: _mbsncmp(U, V, 1) != 0)
if (_mbsnbcmp(U, V, 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_mbsnbcmp' is called without explicitly comparing result
// CHECK-FIXES: _mbsnbcmp(U, V, 1) != 0)
if (_mbsnbicmp(U, V, 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_mbsnbicmp' is called without explicitly comparing result
// CHECK-FIXES: _mbsnbicmp(U, V, 1) != 0)
if (_mbsicmp(U, V))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_mbsicmp' is called without explicitly comparing result
// CHECK-FIXES: _mbsicmp(U, V) != 0)
if (_mbsnicmp(U, V, 1))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_mbsnicmp' is called without explicitly comparing result
// CHECK-FIXES: _mbsnicmp(U, V, 1) != 0)
if (_mbscmp_l(U, V, locale))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_mbscmp_l' is called without explicitly comparing result
// CHECK-FIXES: _mbscmp_l(U, V, locale) != 0)
if (_mbsncmp_l(U, V, 1, locale))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_mbsncmp_l' is called without explicitly comparing result
// CHECK-FIXES: _mbsncmp_l(U, V, 1, locale) != 0)
if (_mbsicmp_l(U, V, locale))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_mbsicmp_l' is called without explicitly comparing result
// CHECK-FIXES: _mbsicmp_l(U, V, locale) != 0)
if (_mbsnicmp_l(U, V, 1, locale))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_mbsnicmp_l' is called without explicitly comparing result
// CHECK-FIXES: _mbsnicmp_l(U, V, 1, locale) != 0)
if (_mbsnbcmp_l(U, V, 1, locale))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_mbsnbcmp_l' is called without explicitly comparing result
// CHECK-FIXES: _mbsnbcmp_l(U, V, 1, locale) != 0)
if (_mbsnbicmp_l(U, V, 1, locale))
return 0;
// CHECK-MESSAGES: [[@LINE-2]]:7: warning: function '_mbsnbicmp_l' is called without explicitly comparing result
// CHECK-FIXES: _mbsnbicmp_l(U, V, 1, locale) != 0)
return 1;
}
static Machine *
findMachineType()
{
// Search for an exact match by SysParam stuff
wchar_t oeminfo[128], platform[128];
SystemParametersInfo(SPI_GETOEMINFO, sizeof(oeminfo), oeminfo, 0);
SystemParametersInfo(SPI_GETPLATFORMTYPE, sizeof(platform), platform, 0);
Output("Trying to detect machine (Plat='%ls' OEM='%ls')"
, platform, oeminfo);
// Try to lookup processor type.
PROCESSOR_INFO pinfo;
DWORD rsize;
memset(&pinfo, sizeof(pinfo), 0);
int ret = KernelIoControl(IOCTL_PROCESSOR_INFORMATION, NULL, 0
, &pinfo, sizeof(pinfo), &rsize);
if (ret)
Output("Wince reports processor: core=%ls name=%ls cat=%ls vend=%ls"
, pinfo.szProcessCore, pinfo.szProcessorName
, pinfo.szCatalogNumber, pinfo.szVendor);
Machine **p = mach_start;
while (p < &mach_end) {
Machine *m = *p;
p++;
Output("Looking at machine %s", m->name);
if (wcscmp(platform, m->PlatformType) != 0)
continue;
for (uint32 j=0; j<ARRAY_SIZE(m->OEMInfo) && m->OEMInfo[j]; j++) {
int len = wcslen(m->OEMInfo[j]);
if (_wcsnicmp(oeminfo, m->OEMInfo[j], len) == 0)
// Match
return m;
}
}
// Couldn't find a machine - try by architecture.
p = mach_start;
while (p < &mach_end) {
Machine *m = *p;
p++;
if (m->OEMInfo[0])
// Not an architecture.
continue;
Output("Looking at arch %s", m->name);
for (uint32 j=0; j<ARRAY_SIZE(m->CPUInfo) && m->CPUInfo[j]; j++) {
int len = wcslen(m->CPUInfo[j]);
if (_wcsnicmp(pinfo.szProcessorName, m->CPUInfo[j], len) == 0
|| _wcsnicmp(pinfo.szProcessCore, m->CPUInfo[j], len) == 0)
// Match
return m;
}
int ret = 0;
TRY_EXCEPTION_HANDLER {
ret = m->detect();
} CATCH_EXCEPTION_HANDLER {
Output("Exception on arch %s detect", m->name);
}
if (ret)
// Match
return m;
}
// Nothing matched - use generic default.
return &RefMachine;
}
void CModelReaderNode_Slices1507_Segment::OnAttribute(_In_z_ const nfWChar * pAttributeName, _In_z_ const nfWChar * pAttributeValue) {
if (wcscmp(pAttributeName, XML_3MF_ATTRIBUTE_SLICESEGMENT_V2) == 0) {
m_pSlice->addPolygonIndex(m_PolygonIndex, fnWStringToInt32(pAttributeValue));
}
}
// handle WinHTTP callbacks (which can be in a worker thread context)
VOID CALLBACK WinHttpIO::asynccallback(HINTERNET hInternet, DWORD_PTR dwContext,
DWORD dwInternetStatus,
LPVOID lpvStatusInformation,
DWORD dwStatusInformationLength)
{
WinHttpContext* httpctx = (WinHttpContext*)dwContext;
WinHttpIO* httpio = (WinHttpIO*)httpctx->httpio;
if (dwInternetStatus == WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING)
{
LOG_verbose << "Closing request";
assert(!httpctx->req);
if (httpctx->gzip)
{
inflateEnd(&httpctx->z);
}
delete httpctx;
return;
}
httpio->lock();
HttpReq* req = httpctx->req;
// request cancellations that occured after asynccallback() was entered are caught here
if (!req)
{
LOG_verbose << "Request cancelled";
httpio->unlock();
return;
}
switch (dwInternetStatus)
{
case WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE:
{
DWORD size = *(DWORD*)lpvStatusInformation;
if (!size)
{
if (req->binary)
{
LOG_debug << "[received " << (req->buf ? req->buflen : req->in.size()) << " bytes of raw data]";
}
else
{
if(req->in.size() < 2048)
{
LOG_debug << "Received: " << req->in.c_str();
}
else
{
LOG_debug << "Received: " << req->in.substr(0,2048).c_str();
}
}
LOG_debug << "Request finished with HTTP status: " << req->httpstatus;
req->status = req->httpstatus == 200 ? REQ_SUCCESS : REQ_FAILURE;
httpio->success = true;
}
else
{
LOG_verbose << "Data available. Remaining: " << size << " bytes";
char* ptr;
if (httpctx->gzip)
{
m_off_t zprevsize = httpctx->zin.size();
httpctx->zin.resize(zprevsize + size);
ptr = (char*)httpctx->zin.data() + zprevsize;
}
else
{
ptr = (char*)req->reserveput((unsigned*)&size);
req->bufpos += size;
}
if (!WinHttpReadData(hInternet, ptr, size, NULL))
{
LOG_err << "Unable to get more data. Code: " << GetLastError();
httpio->cancel(req);
}
}
httpio->httpevent();
break;
}
case WINHTTP_CALLBACK_STATUS_READ_COMPLETE:
LOG_verbose << "Read complete";
if (dwStatusInformationLength)
{
LOG_verbose << dwStatusInformationLength << " bytes received";
if (req->httpio)
{
req->httpio->lastdata = Waiter::ds;
}
if (httpctx->gzip)
{
httpctx->z.next_in = (Bytef*)lpvStatusInformation;
httpctx->z.avail_in = dwStatusInformationLength;
req->bufpos += httpctx->z.avail_out;
int t = inflate(&httpctx->z, Z_SYNC_FLUSH);
req->bufpos -= httpctx->z.avail_out;
if ((char*)lpvStatusInformation + dwStatusInformationLength ==
httpctx->zin.data() + httpctx->zin.size())
{
httpctx->zin.clear();
}
if (t != Z_OK && (t != Z_STREAM_END || httpctx->z.avail_out))
{
LOG_err << "GZIP error";
httpio->cancel(req);
}
}
if (!WinHttpQueryDataAvailable(httpctx->hRequest, NULL))
{
LOG_err << "Error on WinHttpQueryDataAvailable. Code: " << GetLastError();
httpio->cancel(req);
httpio->httpevent();
}
}
break;
case WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE:
{
DWORD statusCode;
DWORD statusCodeSize = sizeof(statusCode);
if (!WinHttpQueryHeaders(httpctx->hRequest,
WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
WINHTTP_HEADER_NAME_BY_INDEX,
&statusCode,
&statusCodeSize,
WINHTTP_NO_HEADER_INDEX))
{
LOG_err << "Error getting headers. Code: " << GetLastError();
httpio->cancel(req);
httpio->httpevent();
}
else
{
LOG_verbose << "Headers available";
req->httpstatus = statusCode;
if (req->httpio)
{
req->httpio->lastdata = Waiter::ds;
}
if (!req->buf)
{
// obtain original content length - always present if gzip is in use
DWORD contentLength;
DWORD contentLengthSize = sizeof(contentLength);
if (WinHttpQueryHeaders(httpctx->hRequest,
WINHTTP_QUERY_CUSTOM | WINHTTP_QUERY_FLAG_NUMBER,
L"Original-Content-Length",
&contentLength,
&contentLengthSize,
WINHTTP_NO_HEADER_INDEX))
{
LOG_verbose << "Content-Length: " << contentLength;
req->setcontentlength(contentLength);
// check for gzip content encoding
WCHAR contentEncoding[16];
DWORD contentEncodingSize = sizeof(contentEncoding);
httpctx->gzip = WinHttpQueryHeaders(httpctx->hRequest,
WINHTTP_QUERY_CONTENT_ENCODING,
WINHTTP_HEADER_NAME_BY_INDEX,
&contentEncoding,
&contentEncodingSize,
WINHTTP_NO_HEADER_INDEX)
&& !wcscmp(contentEncoding, L"gzip");
if (httpctx->gzip)
{
LOG_verbose << "Using GZIP";
httpctx->z.zalloc = Z_NULL;
httpctx->z.zfree = Z_NULL;
httpctx->z.opaque = Z_NULL;
httpctx->z.avail_in = 0;
httpctx->z.next_in = Z_NULL;
inflateInit2(&httpctx->z, MAX_WBITS+16);
req->in.resize(contentLength);
httpctx->z.avail_out = contentLength;
httpctx->z.next_out = (unsigned char*)req->in.data();
}
else
{
LOG_verbose << "Not using GZIP";
}
}
else
{
LOG_verbose << "Content-Length not available";
}
}
if (!WinHttpQueryDataAvailable(httpctx->hRequest, NULL))
{
LOG_err << "Unable to query data. Code: " << GetLastError();
httpio->cancel(req);
httpio->httpevent();
}
else if (httpio->waiter && httpio->noinetds)
{
httpio->inetstatus(true);
}
}
break;
}
case WINHTTP_CALLBACK_STATUS_REQUEST_ERROR:
{
DWORD e = GetLastError();
LOG_err << "Request error. Code: " << e;
if (httpio->waiter && e != ERROR_WINHTTP_TIMEOUT)
{
httpio->inetstatus(false);
}
}
// fall through
case WINHTTP_CALLBACK_STATUS_SECURE_FAILURE:
if (dwInternetStatus == WINHTTP_CALLBACK_STATUS_SECURE_FAILURE)
{
LOG_err << "Security check failed. Code: " << (*(DWORD*)lpvStatusInformation);
}
httpio->cancel(req);
httpio->httpevent();
break;
case WINHTTP_CALLBACK_STATUS_SENDING_REQUEST:
{
PCCERT_CONTEXT cert;
DWORD len = sizeof cert;
if (WinHttpQueryOption(httpctx->hRequest, WINHTTP_OPTION_SERVER_CERT_CONTEXT, &cert, &len))
{
CRYPT_BIT_BLOB* pkey = &cert->pCertInfo->SubjectPublicKeyInfo.PublicKey;
// this is an SSL connection: verify public key to prevent MITM attacks
if (pkey->cbData != 270
|| (memcmp(pkey->pbData, "\x30\x82\x01\x0a\x02\x82\x01\x01\x00" APISSLMODULUS1
"\x02" APISSLEXPONENTSIZE APISSLEXPONENT, 270)
&& memcmp(pkey->pbData, "\x30\x82\x01\x0a\x02\x82\x01\x01\x00" APISSLMODULUS2
"\x02" APISSLEXPONENTSIZE APISSLEXPONENT, 270)))
{
LOG_err << "Certificate error. Possible MITM attack!!";
CertFreeCertificateContext(cert);
httpio->cancel(req);
httpio->httpevent();
break;
}
CertFreeCertificateContext(cert);
}
else
{
LOG_verbose << "Unable to get server certificate. Code: " << GetLastError();
}
break;
}
case WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE:
case WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE:
if (httpctx->postpos < httpctx->postlen)
{
LOG_verbose << "Chunk written";
unsigned pos = httpctx->postpos;
unsigned t = httpctx->postlen - pos;
if (t > HTTP_POST_CHUNK_SIZE)
{
t = HTTP_POST_CHUNK_SIZE;
}
httpctx->postpos += t;
if (!WinHttpWriteData(httpctx->hRequest, (LPVOID)(httpctx->postdata + pos), t, NULL))
{
LOG_err << "Error writting data. Code: " << GetLastError();
req->httpio->cancel(req);
}
httpio->httpevent();
}
else
{
LOG_verbose << "Request written";
if (!WinHttpReceiveResponse(httpctx->hRequest, NULL))
{
LOG_err << "Error receiving response. Code: " << GetLastError();
httpio->cancel(req);
httpio->httpevent();
}
httpctx->postdata = NULL;
}
}
httpio->unlock();
}
bool operator()(const wchar_t *a, const wchar_t *b) const { return wcscmp(a, b) < 0; }
/*
** Called during each update of the main measure.
**
*/
void PlayerWinamp::UpdateData()
{
if (m_Initialized || CheckWindow())
{
const auto playing = SendMessage(m_Window, WM_WA_IPC, 0, IPC_ISPLAYING);
if (playing == 0)
{
// Make sure Winamp is still active
if (!IsWindow(m_Window))
{
m_Initialized = false;
ClearData();
if (m_WinampHandle) CloseHandle(m_WinampHandle);
}
else if (m_State != STATE_STOPPED)
{
ClearData(false);
}
// Don't continue if Winamp has quit or is stopped
return;
}
else
{
m_State = (playing == 1) ? STATE_PLAYING : STATE_PAUSED;
m_Position = (UINT)SendMessage(m_Window, WM_WA_IPC, 0, IPC_GETOUTPUTTIME) / 1000; // ms to secs
m_Volume = ((UINT)SendMessage(m_Window, WM_WA_IPC, -666, IPC_SETVOLUME) * 100) / 255; // 0 - 255 to 0 - 100
}
WCHAR wBuffer[MAX_PATH];
char cBuffer[MAX_PATH];
if (m_UseUnicodeAPI)
{
if (!ReadProcessMemory(m_WinampHandle, m_WinampAddress, &wBuffer, sizeof(wBuffer), nullptr))
{
// Failed to read memory
return;
}
}
else
{
// MediaMonkey doesn't support wide IPC messages
const auto pos = SendMessage(m_Window, WM_WA_IPC, 0, IPC_GETLISTPOS);
LPCVOID address = (LPCVOID)SendMessage(m_Window, WM_WA_IPC, pos, IPC_GETPLAYLISTFILE);
if (!ReadProcessMemory(m_WinampHandle, address, &cBuffer, sizeof(cBuffer), nullptr))
{
// Failed to read memory
return;
}
mbstowcs(wBuffer, cBuffer, MAX_PATH);
}
if (wcscmp(wBuffer, m_FilePath.c_str()) != 0)
{
++m_TrackCount;
m_FilePath = wBuffer;
m_PlayingStream = (m_FilePath.find(L"://") != std::wstring::npos);
if (!m_PlayingStream)
{
const int duration = (int)SendMessage(m_Window, WM_WA_IPC, 1, IPC_GETOUTPUTTIME);
m_Duration = (duration != -1) ? duration : 0;
m_Rating = (UINT)SendMessage(m_Window, WM_WA_IPC, 0, IPC_GETRATING);
m_Shuffle = SendMessage(m_Window, WM_WA_IPC, 0, IPC_GET_SHUFFLE) != 0;
m_Repeat = SendMessage(m_Window, WM_WA_IPC, 0, IPC_GET_REPEAT) != 0;
TagLib::FileRef fr(wBuffer, false);
TagLib::Tag* tag = fr.tag();
if (tag)
{
m_Artist = tag->artist().toWString();
m_Album = tag->album().toWString();
m_Title = tag->title().toWString();
m_Number = tag->track();
m_Year = tag->year();
if (m_Measures & MEASURE_LYRICS)
{
FindLyrics();
}
}
else if (m_Measures & MEASURE_LYRICS)
{
m_Lyrics.clear();
}
// Find cover if needed
if (m_Measures & MEASURE_COVER)
{
if (tag && CCover::GetEmbedded(fr, m_TempCoverPath))
{
// Got everything, return
m_CoverPath = m_TempCoverPath;
return;
}
std::wstring trackFolder = CCover::GetFileFolder(m_FilePath);
if (tag && !m_Album.empty())
{
// Winamp stores covers usually as %album%.jpg
std::wstring file = m_Album;
std::wstring::size_type end = file.length();
for (std::wstring::size_type pos = 0; pos < end; ++pos)
{
// Replace reserved chars according to Winamp specs
switch (file[pos])
{
case L'?':
case L'*':
case L'|':
file[pos] = L'_';
break;
case L'/':
case L'\\':
case L':':
file[pos] = L'-';
break;
case L'\"':
file[pos] = L'\'';
break;
case L'<':
file[pos] = L'(';
break;
case L'>':
file[pos] = L')';
break;
}
}
if (CCover::GetLocal(file, trackFolder, m_CoverPath))
{
// %album% art file found
return;
}
}
if (!CCover::GetLocal(L"cover", trackFolder, m_CoverPath) &&
!CCover::GetLocal(L"folder", trackFolder, m_CoverPath))
{
// Nothing found
m_CoverPath.clear();
}
}
if (tag)
{
return;
}
}
else
{
m_Rating = 0;
m_Duration = 0;
m_CoverPath.clear();
}
}
else if (!m_PlayingStream)
{
if (m_Duration == 0)
{
const int duration = (int)SendMessage(m_Window, WM_WA_IPC, 1, IPC_GETOUTPUTTIME);
m_Duration = (duration != -1) ? duration : 0;
}
return;
}
// TagLib couldn't parse the file or Winamp is playing a stream, try to get title
if (m_UseUnicodeAPI)
{
LPCVOID address = (LPCVOID)SendMessage(m_Window, WM_WA_IPC, 0, IPC_GET_PLAYING_TITLE);
ReadProcessMemory(m_WinampHandle, address, &wBuffer, sizeof(wBuffer), nullptr);
}
else
{
const auto pos = SendMessage(m_Window, WM_WA_IPC, 0, IPC_GETLISTPOS);
LPCVOID address = (LPCVOID)SendMessage(m_Window, WM_WA_IPC, pos, IPC_GETPLAYLISTTITLE);
ReadProcessMemory(m_WinampHandle, address, &cBuffer, sizeof(cBuffer), nullptr);
mbstowcs(wBuffer, cBuffer, MAX_PATH);
}
std::wstring title = wBuffer;
std::wstring::size_type pos = title.find(L" - ");
if (pos != std::wstring::npos)
{
m_Artist.assign(title, 0, pos);
pos += 3; // Skip " - "
m_Title.assign(title, pos, title.length() - pos);
m_Album.clear();
if (m_PlayingStream)
{
// Remove crap from title if playing radio
pos = m_Title.find(L" (");
if (pos != std::wstring::npos)
{
m_Title.resize(pos);
}
}
}
else
{
m_Title = title;
m_Artist.clear();
m_Album.clear();
}
}
}
void Mixer::getPortsInfo() {
MIXERCAPS mc;
mixerGetDevCaps((UINT)hMixer, &mc, sizeof mc);
MIXERLINE mlt;
unsigned i;
for (i = 0; i < mc.cDestinations; ++i) {
memset(&mlt, 0, sizeof mlt);
mlt.cbStruct = sizeof mlt;
mlt.dwDestination = i;
if (mixerGetLineInfo((HMIXEROBJ)hMixer, &mlt, MIXER_GETLINEINFOF_DESTINATION) != MMSYSERR_NOERROR) continue;
if (mlt.dwLineID == dwRecLineID) break; // this is the destination we're interested in
}
ports = new AudioInputPort[mlt.cConnections];
numPorts = mlt.cConnections;
for (i = 0; i < numPorts; ++i) {
MIXERLINE mlc;
memcpy(&mlc, &mlt, sizeof mlc);
mlc.dwSource = i;
mixerGetLineInfo((HMIXEROBJ)hMixer, &mlc, MIXER_GETLINEINFOF_SOURCE/*|MIXER_OBJECTF_HMIXER*/);
ports[i].tag = mlc.dwLineID;
ports[i].dwComponentType = mlc.dwComponentType;
#ifdef UNICODE
wcstombs(ports[i].name, mlc.szName, MIXER_LONG_NAME_CHARS);
#else
strncpy(ports[i].name, mlc.szName, MIXER_LONG_NAME_CHARS);
#endif
}
// Make the microphone the first port in the list:
for (i = 1; i < numPorts; ++i) {
#ifdef OLD_MICROPHONE_TESTING_CODE
if (_strnicmp("mic", ports[i].name, 3) == 0 ||
_strnicmp("mik", ports[i].name, 3) == 0) {
#else
if (ports[i].dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE) {
#endif
AudioInputPort tmp = ports[0];
ports[0] = ports[i];
ports[i] = tmp;
}
}
}
Boolean Mixer::enableInputPort(unsigned portIndex, char const*& errReason, MMRESULT& errCode) {
errReason = NULL; // unless there's an error
AudioInputPort& port = ports[portIndex];
MIXERCONTROL mc;
mc.cMultipleItems = 1; // in case it doesn't get set below
MIXERLINECONTROLS mlc;
#if 0 // the following doesn't seem to be needed, and can fail:
mlc.cbStruct = sizeof mlc;
mlc.pamxctrl = &mc;
mlc.cbmxctrl = sizeof (MIXERCONTROL);
mlc.dwLineID = port.tag;
mlc.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
if ((errCode = mixerGetLineControls((HMIXEROBJ)hMixer, &mlc, MIXER_GETLINECONTROLSF_ONEBYTYPE/*|MIXER_OBJECTF_HMIXER*/)) != MMSYSERR_NOERROR) {
errReason = "mixerGetLineControls()";
return False;
}
#endif
MIXERLINE ml;
memset(&ml, 0, sizeof (MIXERLINE));
ml.cbStruct = sizeof (MIXERLINE);
ml.dwLineID = port.tag;
if ((errCode = mixerGetLineInfo((HMIXEROBJ)hMixer, &ml, MIXER_GETLINEINFOF_LINEID)) != MMSYSERR_NOERROR) {
errReason = "mixerGetLineInfo()1";
return False;
}
#ifdef UNICODE
wchar_t portname[MIXER_LONG_NAME_CHARS+1];
wcsncpy(portname, ml.szName, MIXER_LONG_NAME_CHARS);
#else
char portname[MIXER_LONG_NAME_CHARS+1];
strncpy(portname, ml.szName, MIXER_LONG_NAME_CHARS);
#endif
memset(&ml, 0, sizeof (MIXERLINE));
ml.cbStruct = sizeof (MIXERLINE);
ml.dwLineID = dwRecLineID;
if ((errCode = mixerGetLineInfo((HMIXEROBJ)hMixer, &ml, MIXER_GETLINEINFOF_LINEID/*|MIXER_OBJECTF_HMIXER*/)) != MMSYSERR_NOERROR) {
errReason = "mixerGetLineInfo()2";
return False;
}
// Get Mixer/MUX control information (need control id to set and get control details)
mlc.cbStruct = sizeof mlc;
mlc.dwLineID = ml.dwLineID;
mlc.cControls = 1;
mc.cbStruct = sizeof mc; // Needed???#####
mc.dwControlID = 0xDEADBEEF; // For testing #####
mlc.pamxctrl = &mc;
mlc.cbmxctrl = sizeof mc;
mlc.dwControlType = MIXERCONTROL_CONTROLTYPE_MUX; // Single Select
if ((errCode = mixerGetLineControls((HMIXEROBJ)hMixer, &mlc, MIXER_GETLINECONTROLSF_ONEBYTYPE/*|MIXER_OBJECTF_HMIXER*/)) != MMSYSERR_NOERROR) {
mlc.dwControlType = MIXERCONTROL_CONTROLTYPE_MIXER; // Multiple Select
mixerGetLineControls((HMIXEROBJ)hMixer, &mlc, MIXER_GETLINECONTROLSF_ONEBYTYPE/*|MIXER_OBJECTF_HMIXER*/);
}
unsigned matchLine = 0;
if (mc.cMultipleItems > 1) {
// Before getting control, we need to know which line to grab.
// We figure this out by listing the lines, and comparing names:
MIXERCONTROLDETAILS mcd;
mcd.cbStruct = sizeof mcd;
mcd.cChannels = ml.cChannels;
mcd.cMultipleItems = mc.cMultipleItems;
MIXERCONTROLDETAILS_LISTTEXT* mcdlText = new MIXERCONTROLDETAILS_LISTTEXT[mc.cMultipleItems];
mcd.cbDetails = sizeof (MIXERCONTROLDETAILS_LISTTEXT);
mcd.paDetails = mcdlText;
if (mc.dwControlID != 0xDEADBEEF) { // we know the control id for real
mcd.dwControlID = mc.dwControlID;
if ((errCode = mixerGetControlDetails((HMIXEROBJ)hMixer, &mcd, MIXER_GETCONTROLDETAILSF_LISTTEXT/*|MIXER_OBJECTF_HMIXER*/)) != MMSYSERR_NOERROR) {
delete[] mcdlText;
errReason = "mixerGetControlDetails()1";
return False;
}
} else {
// Hack: We couldn't find a MUX or MIXER control, so try to guess the control id:
for (mc.dwControlID = 0; mc.dwControlID < 32; ++mc.dwControlID) {
mcd.dwControlID = mc.dwControlID;
if ((errCode = mixerGetControlDetails((HMIXEROBJ)hMixer, &mcd, MIXER_GETCONTROLDETAILSF_LISTTEXT/*|MIXER_OBJECTF_HMIXER*/)) == MMSYSERR_NOERROR) break;
}
if (mc.dwControlID == 32) { // unable to guess mux/mixer control id
delete[] mcdlText;
errReason = "mixerGetControlDetails()2";
return False;
}
}
#ifdef UNICODE
for (unsigned i = 0; i < mcd.cMultipleItems; ++i) {
if (wcscmp(mcdlText[i].szName, portname) == 0) {
matchLine = i;
break;
}
}
#else
for (unsigned i = 0; i < mcd.cMultipleItems; ++i) {
if (strcmp(mcdlText[i].szName, portname) == 0) {
matchLine = i;
break;
}
}
#endif
delete[] mcdlText;
}
// Now get control itself:
MIXERCONTROLDETAILS mcd;
mcd.cbStruct = sizeof mcd;
mcd.dwControlID = mc.dwControlID;
mcd.cChannels = ml.cChannels;
mcd.cMultipleItems = mc.cMultipleItems;
MIXERCONTROLDETAILS_BOOLEAN* mcdbState = new MIXERCONTROLDETAILS_BOOLEAN[mc.cMultipleItems];
mcd.paDetails = mcdbState;
mcd.cbDetails = sizeof (MIXERCONTROLDETAILS_BOOLEAN);
if ((errCode = mixerGetControlDetails((HMIXEROBJ)hMixer, &mcd, MIXER_GETCONTROLDETAILSF_VALUE/*|MIXER_OBJECTF_HMIXER*/)) != MMSYSERR_NOERROR) {
delete[] mcdbState;
errReason = "mixerGetControlDetails()3";
return False;
}
for (unsigned j = 0; j < mcd.cMultipleItems; ++j) {
mcdbState[j].fValue = (j == matchLine);
}
if ((errCode = mixerSetControlDetails((HMIXEROBJ)hMixer, &mcd, MIXER_OBJECTF_HMIXER)) != MMSYSERR_NOERROR) {
delete[] mcdbState;
errReason = "mixerSetControlDetails()";
return False;
}
delete[] mcdbState;
return True;
}
// ILDOMEventListener
STDMETHODIMP CEXMLDocumentStyleSheetsView::handleEvent(ILDOMEvent* evt)
{
CComBSTR type;
evt->get_type(&type);
// BOOL bUpdate = FALSE;
if (!wcscmp(type, L"DOMNodeInserted"))
{
CComQIPtr<ILDOMMutationEvent> mut = evt;
CComPtr<ILDOMEventTarget> target;
mut->get_target(&target);
CComQIPtr<ILDOMNode> node = target;
CComQIPtr<ILLinkStyle> linkStyle = node;
if (linkStyle)
{
CComPtr<ILCSSStyleSheet> styleSheet;
linkStyle->get_sheet((ILStyleSheet**)&styleSheet);
styleSheet->addHandler(this);
DWORD newItem;
m_treeCtl->InsertItem((DWORD)styleSheet.p, NULL/*parentItem*/, NULL, NULL, 0/*pNewItem->m_iIcon*/, 1/*pNewItem->m_cChildren*/, &newItem);
CComPtr<ILCSSRuleList> ruleList;
styleSheet->get_cssRules(&ruleList);
PopulateRules(newItem, ruleList);
}
}
else if (!wcscmp(type, L"DOMNodeRemovedFromDocument"))
{
CComQIPtr<ILDOMMutationEvent> mut = evt;
CComPtr<ILDOMEventTarget> target;
mut->get_target(&target);
CComQIPtr<ILDOMNode> node = target;
CComQIPtr<ILLinkStyle> linkStyle = node;
if (linkStyle)
{
CComPtr<ILCSSStyleSheet> styleSheet;
linkStyle->get_sheet((ILStyleSheet**)&styleSheet);
DWORD root;
m_treeCtl->GetRootItem(&root);
DWORD item;
m_treeCtl->GetFirstChildItem(root, &item);
while (item)
{
DWORD itemdata;
m_treeCtl->GetItemInfo(item, &itemdata, NULL, NULL);
CComQIPtr<ILCSSStyleSheet> styleSheet2 = (IUnknown*)itemdata;
if (styleSheet2 == styleSheet)
{
m_treeCtl->DeleteItem(item);
break;
}
m_treeCtl->GetNextSiblingItem(item, &item);
}
}
/*
for (int i = 0; i < m_listView.m_items.GetSize(); i++)
{
if (m_listView.m_items[i]->m_element == node)
{
CComQIPtr<ILDOMEventTarget> eventTarget = m_listView.m_items[i]->m_element;
eventTarget->removeEventListener(L"DOMNodeRemovedFromDocument", this, VARIANT_FALSE);
m_listView.DeleteItem(i);
break;
}
}
*/
}
return S_OK;
}
/**
* Determines whether we're staging an update.
*
* @param argc The argc value normally sent to updater.exe
* @param argv The argv value normally sent to updater.exe
* @param boolean True if we're staging an update
*/
static bool
IsUpdateBeingStaged(int argc, LPWSTR *argv)
{
// PID will be set to -1 if we're supposed to stage an update.
return argc == 4 && !wcscmp(argv[3], L"-1");
}
/**Read the XML config file. Currently contains keyboard choices.*/
void read_config_file()
{
TrainerConfig *result = new TrainerConfig();
CoInitialize(NULL);
//read XML
MSXML2::IXMLDOMDocumentPtr spXMLDoc;
spXMLDoc.CreateInstance(__uuidof(MSXML2::DOMDocument60));
if (!spXMLDoc->load("ent-config.xml"))
{
write_text_to_log_file("No config found, using defaults");
config = result; //the default config
}
IXMLDOMNodeListPtr nodes = spXMLDoc->selectNodes(L"//ent-config/keys/key");
long length;
nodes->get_length(&length);
for (int i = 0; i < length; i++)
{
IXMLDOMNode *node;
nodes->get_item(i, &node);
IXMLDOMNamedNodeMap *attribs;
node->get_attributes(&attribs);
long length_attribs;
attribs->get_length(&length_attribs);
char *attrib_key_func = NULL;
char *attrib_key_value = NULL;
for (long j = 0; j < length_attribs; j++)
{
IXMLDOMNode *attribNode;
attribs->get_item(j, &attribNode);
attribNode->get_nodeName(&bstr);
if (wcscmp(bstr, L"function") == 0)
{
VARIANT var;
VariantInit(&var);
attribNode->get_nodeValue(&var);
attrib_key_func = _com_util::ConvertBSTRToString(V_BSTR(&var));
}
else if (wcscmp(bstr, L"value") == 0)
{
VARIANT var;
VariantInit(&var);
attribNode->get_nodeValue(&var);
attrib_key_value = _com_util::ConvertBSTRToString(V_BSTR(&var));
}
SysFreeString(bstr);
attribNode->Release();
}
if (attrib_key_func != NULL && attrib_key_value != NULL)
{
result->get_key_config()->set_key(attrib_key_func, attrib_key_value);
}
delete attrib_key_func;
delete attrib_key_value;
attribs->Release();
node->Release();
}
//nodes->Release(); //don't do this, it crashes on exit
spXMLDoc.Release();
CoUninitialize();
config = result;
}
bool GetFileFormat(File& file, uintptr_t& nCodePage, bool* pSignatureFound, bool bUseHeuristics)
{
DWORD dwTemp=0;
bool bSignatureFound = false;
bool bDetect=false;
DWORD Readed = 0;
if (file.Read(&dwTemp, sizeof(dwTemp), Readed) && Readed > 1 ) // minimum signature size is 2 bytes
{
if (LOWORD(dwTemp) == SIGN_UNICODE)
{
nCodePage = CP_UNICODE;
file.SetPointer(2, nullptr, FILE_BEGIN);
bSignatureFound = true;
}
else if (LOWORD(dwTemp) == SIGN_REVERSEBOM)
{
nCodePage = CP_REVERSEBOM;
file.SetPointer(2, nullptr, FILE_BEGIN);
bSignatureFound = true;
}
else if ((dwTemp & 0x00FFFFFF) == SIGN_UTF8)
{
nCodePage = CP_UTF8;
file.SetPointer(3, nullptr, FILE_BEGIN);
bSignatureFound = true;
}
else
{
file.SetPointer(0, nullptr, FILE_BEGIN);
}
}
if (bSignatureFound)
{
bDetect = true;
}
else if (bUseHeuristics)
{
file.SetPointer(0, nullptr, FILE_BEGIN);
DWORD Size=0x8000; // BUGBUG. TODO: configurable
LPVOID Buffer=xf_malloc(Size);
DWORD ReadSize = 0;
bool ReadResult = file.Read(Buffer, Size, ReadSize);
file.SetPointer(0, nullptr, FILE_BEGIN);
if (ReadResult && ReadSize)
{
int test=
IS_TEXT_UNICODE_STATISTICS|
IS_TEXT_UNICODE_REVERSE_STATISTICS|
IS_TEXT_UNICODE_CONTROLS|
IS_TEXT_UNICODE_REVERSE_CONTROLS|
IS_TEXT_UNICODE_ILLEGAL_CHARS|
IS_TEXT_UNICODE_ODD_LENGTH|
IS_TEXT_UNICODE_NULL_BYTES;
if (IsTextUnicode(Buffer, ReadSize, &test))
{
if (!(test&IS_TEXT_UNICODE_ODD_LENGTH) && !(test&IS_TEXT_UNICODE_ILLEGAL_CHARS))
{
if ((test&IS_TEXT_UNICODE_NULL_BYTES) || (test&IS_TEXT_UNICODE_CONTROLS) || (test&IS_TEXT_UNICODE_REVERSE_CONTROLS))
{
if ((test&IS_TEXT_UNICODE_CONTROLS) || (test&IS_TEXT_UNICODE_STATISTICS))
{
nCodePage=CP_UNICODE;
bDetect=true;
}
else if ((test&IS_TEXT_UNICODE_REVERSE_CONTROLS) || (test&IS_TEXT_UNICODE_REVERSE_STATISTICS))
{
nCodePage=CP_REVERSEBOM;
bDetect=true;
}
}
}
}
else if (IsTextUTF8(static_cast<LPBYTE>(Buffer), ReadSize))
{
nCodePage=CP_UTF8;
bDetect=true;
}
else
{
nsUniversalDetectorEx *ns = new nsUniversalDetectorEx();
ns->HandleData(static_cast<LPCSTR>(Buffer), ReadSize);
ns->DataEnd();
int cp = ns->getCodePage();
if ( cp >= 0 )
{
const wchar_t *deprecated = Opt.strNoAutoDetectCP;
if ( 0 == wcscmp(deprecated, L"-1") )
{
if ( Opt.CPMenuMode )
{
if ( static_cast<UINT>(cp) != GetACP() && static_cast<UINT>(cp) != GetOEMCP() )
{
int selectType = 0;
GeneralCfg->GetValue(FavoriteCodePagesKey, FormatString() << cp, &selectType, 0);
if (0 == (selectType & CPST_FAVORITE))
cp = -1;
}
}
}
else
{
while (*deprecated)
{
while (*deprecated && (*deprecated < L'0' || *deprecated > L'9'))
++deprecated;
int dp = (int)wcstol(deprecated, (wchar_t **)&deprecated, 0);
if (cp == dp)
{
cp = -1;
break;
}
}
}
}
if (cp != -1)
{
nCodePage = cp;
bDetect = true;
}
delete ns;
}
}
xf_free(Buffer);
}
if (pSignatureFound)
{
*pSignatureFound = bSignatureFound;
}
return bDetect;
}
bool CMpaDecSettingsWnd::OnActivate()
{
DWORD dwStyle = WS_VISIBLE|WS_CHILD|WS_TABSTOP;
CRect r;
CPoint p(10, 10);
m_outputformat_static.Create(ResStr(IDS_MPADECSETTINGSWND_0), dwStyle, CRect(p, CSize(120, m_fontheight)), this);
p.y += m_fontheight + 5;
m_outputformat_combo.Create(dwStyle|CBS_DROPDOWNLIST, CRect(p + CSize(10, 0), CSize(100, 200)), this, IDC_PP_COMBO1);
m_outputformat_combo.SetItemData(m_outputformat_combo.AddString(_T("PCM 16 Bit")), SF_PCM16);
m_outputformat_combo.SetItemData(m_outputformat_combo.AddString(_T("PCM 24 Bit")), SF_PCM24);
m_outputformat_combo.SetItemData(m_outputformat_combo.AddString(_T("PCM 32 Bit")), SF_PCM32);
m_outputformat_combo.SetItemData(m_outputformat_combo.AddString(_T("IEEE Float")), SF_FLOAT32);
m_outputformat_combo.SetCurSel(0);
for(int i = 0; i < m_outputformat_combo.GetCount(); i++)
if((int)m_outputformat_combo.GetItemData(i) == m_outputformat)
m_outputformat_combo.SetCurSel(i);
p.y += 30;
CString strSpeak;
strSpeak.Format (_T("%s%s"), ResStr(IDS_MPADECSETTINGSWND_1), GetDolbyMode(m_ddmode));
m_ac3spkcfg_static.Create(ResStr(IDS_MPADECSETTINGSWND_1) + GetDolbyMode(m_ddmode), dwStyle, CRect(p, CSize(220, m_fontheight)), this);
p.y += m_fontheight + 5;
m_ac3spkcfg_combo.Create(dwStyle|CBS_DROPDOWNLIST, CRect(p + CSize(150, 0), CSize(100, 200)), this, IDC_PP_COMBO2);
m_ac3spkcfg_combo.SetItemData(m_ac3spkcfg_combo.AddString(_T("单声道")), A52_MONO);
m_ac3spkcfg_combo.SetItemData(m_ac3spkcfg_combo.AddString(_T("双单声道")), A52_CHANNEL);
m_ac3spkcfg_combo.SetItemData(m_ac3spkcfg_combo.AddString(_T("立体声")), A52_STEREO);
m_ac3spkcfg_combo.SetItemData(m_ac3spkcfg_combo.AddString(_T("杜比立体声")), A52_DOLBY);
m_ac3spkcfg_combo.SetItemData(m_ac3spkcfg_combo.AddString(ResStr(IDS_MPA_3F)), A52_3F);
m_ac3spkcfg_combo.SetItemData(m_ac3spkcfg_combo.AddString(ResStr(IDS_MPA_2F_1R)), A52_2F1R);
m_ac3spkcfg_combo.SetItemData(m_ac3spkcfg_combo.AddString(ResStr(IDS_MPA_3F_1R)), A52_3F1R);
m_ac3spkcfg_combo.SetItemData(m_ac3spkcfg_combo.AddString(ResStr(IDS_MPA_2F_2R)), A52_2F2R);
m_ac3spkcfg_combo.SetItemData(m_ac3spkcfg_combo.AddString(ResStr(IDS_MPA_3F_2R)), A52_3F2R);
m_ac3spkcfg_combo.SetItemData(m_ac3spkcfg_combo.AddString(ResStr(IDS_MPA_CHANNEL_1)), A52_CHANNEL1);
m_ac3spkcfg_combo.SetItemData(m_ac3spkcfg_combo.AddString(ResStr(IDS_MPA_CHANNEL_2)), A52_CHANNEL2);
for(int i = 0, sel = abs(m_ac3spkcfg) & A52_CHANNEL_MASK; i < m_ac3spkcfg_combo.GetCount(); i++)
if((int)m_ac3spkcfg_combo.GetItemData(i) == sel)
m_ac3spkcfg_combo.SetCurSel(i);
m_ac3spkcfg_combo.GetWindowRect(r);
ScreenToClient(r);
m_ac3lfe_check.Create(_T("LFE"), dwStyle|BS_AUTOCHECKBOX, CRect(CPoint(r.left, r.bottom + 3), CSize(50, m_fontheight)), this, IDC_PP_CHECK4);
m_ac3lfe_check.SetCheck(!!(abs(m_ac3spkcfg) & A52_LFE));
for(int i = 0, h = max(20, m_fontheight)+1; i < countof(m_ac3spkcfg_radio); i++, p.y += h)
{
static const TCHAR* labels[] = {m_strDecodeToSpeaker, _T("SPDIF")};
DWORD ddwStyle = dwStyle;
if(wcscmp(labels[i],_T("SPDIF")) == 0){
ddwStyle = (dwStyle& ~WS_VISIBLE);
}
m_ac3spkcfg_radio[i].Create(labels[i],ddwStyle|BS_AUTORADIOBUTTON|(i == 0 ? WS_GROUP : 0), CRect(p + CPoint(10, 0), CSize(140, h)), this, IDC_PP_RADIO1+i);
}
CheckRadioButton(IDC_PP_RADIO1, IDC_PP_RADIO2, m_ac3spkcfg >= 0 ? IDC_PP_RADIO1 : IDC_PP_RADIO2);
p.y += 5;
m_ac3spkcfg_check.Create(ResStr(IDS_MPA_DYNRANGE), dwStyle|BS_AUTOCHECKBOX, CRect(p + CPoint(10, 0), CSize(150, m_fontheight)), this, IDC_PP_CHECK1);
m_ac3spkcfg_check.SetCheck(m_ac3drc);
p.y += m_fontheight + 10;
m_dtsspkcfg_static.Create(ResStr(IDS_MPADECSETTINGSWND_7), dwStyle, CRect(p, CSize(120, m_fontheight)), this);
p.y += m_fontheight + 5;
m_dtsspkcfg_combo.Create(dwStyle|CBS_DROPDOWNLIST, CRect(p + CSize(150, 0), CSize(100, 200)), this, IDC_PP_COMBO3);
m_dtsspkcfg_combo.SetItemData(m_dtsspkcfg_combo.AddString(_T("单声道")), DTS_MONO);
m_dtsspkcfg_combo.SetItemData(m_dtsspkcfg_combo.AddString(_T("双单声道")), DTS_CHANNEL);
m_dtsspkcfg_combo.SetItemData(m_dtsspkcfg_combo.AddString(_T("立体声")), DTS_STEREO);
//m_dtsspkcfg_combo.SetItemData(m_dtsspkcfg_combo.AddString(_T("Stereo ..")), DTS_STEREO_SUMDIFF);
//m_dtsspkcfg_combo.SetItemData(m_dtsspkcfg_combo.AddString(_T("Stereo ..")), DTS_STEREO_TOTAL);
m_dtsspkcfg_combo.SetItemData(m_dtsspkcfg_combo.AddString(ResStr(IDS_MPA_3F)), DTS_3F);
m_dtsspkcfg_combo.SetItemData(m_dtsspkcfg_combo.AddString(ResStr(IDS_MPA_2F_1R)), DTS_2F1R);
m_dtsspkcfg_combo.SetItemData(m_dtsspkcfg_combo.AddString(ResStr(IDS_MPA_3F_1R)), DTS_3F1R);
m_dtsspkcfg_combo.SetItemData(m_dtsspkcfg_combo.AddString(ResStr(IDS_MPA_2F_2R)), DTS_2F2R);
m_dtsspkcfg_combo.SetItemData(m_dtsspkcfg_combo.AddString(ResStr(IDS_MPA_3F_2R)), DTS_3F2R);
for(int i = 0, sel = abs(m_dtsspkcfg) & DTS_CHANNEL_MASK; i < m_dtsspkcfg_combo.GetCount(); i++)
if((int)m_dtsspkcfg_combo.GetItemData(i) == sel)
m_dtsspkcfg_combo.SetCurSel(i);
m_dtsspkcfg_combo.GetWindowRect(r);
ScreenToClient(r);
m_dtslfe_check.Create(_T("LFE"), dwStyle|BS_AUTOCHECKBOX, CRect(CPoint(r.left, r.bottom + 3), CSize(50, m_fontheight)), this, IDC_PP_CHECK5);
m_dtslfe_check.SetCheck(!!(abs(m_dtsspkcfg) & DTS_LFE));
for(int i = 0, h = max(20, m_fontheight)+1; i < countof(m_dtsspkcfg_radio); i++, p.y += h)
{
static const TCHAR* labels[] = {m_strDecodeToSpeaker, _T("SPDIF")};
DWORD ddwStyle = dwStyle;
if(wcscmp(labels[i],_T("SPDIF")) == 0){
ddwStyle = (dwStyle& ~WS_VISIBLE);
}
m_dtsspkcfg_radio[i].Create(labels[i], ddwStyle|BS_AUTORADIOBUTTON|(i == 0 ? WS_GROUP : 0), CRect(p + CPoint(10, 0), CSize(140, h)), this, IDC_PP_RADIO3+i);
}
CheckRadioButton(IDC_PP_RADIO3, IDC_PP_RADIO4, m_dtsspkcfg >= 0 ? IDC_PP_RADIO3 : IDC_PP_RADIO4);
p.y += 5;
m_dtsspkcfg_check.Create(ResStr(IDS_MPA_DYNRANGE), dwStyle|WS_DISABLED|BS_AUTOCHECKBOX, CRect(p + CPoint(10, 0), CSize(150, m_fontheight)), this, IDC_PP_CHECK2);
m_dtsspkcfg_check.SetCheck(m_dtsdrc);
p.y += m_fontheight + 10;
m_aacspkcfg_static.Create(ResStr(IDS_MPADECSETTINGSWND_11), dwStyle, CRect(p, CSize(120, m_fontheight)), this);
p.y += m_fontheight + 5;
m_aacdownmix_check.Create(ResStr(IDS_MPADECSETTINGSWND_12), dwStyle|BS_AUTOCHECKBOX, CRect(p + CPoint(10, 0), CSize(150, m_fontheight)), this, IDC_PP_CHECK3);
m_aacdownmix_check.SetCheck(m_aacdownmix);
for(CWnd* pWnd = GetWindow(GW_CHILD); pWnd; pWnd = pWnd->GetNextWindow())
pWnd->SetFont(&m_font, FALSE);
return true;
}
static
DWORD WINAPI
ThreadFunc(LPVOID Context)
{
IBindStatusCallback *dl = NULL;
WCHAR path[MAX_PATH];
PWSTR p, q;
HWND Dlg = (HWND) Context;
DWORD dwContentLen, dwBytesWritten, dwBytesRead, dwStatus;
DWORD dwCurrentBytesRead = 0;
DWORD dwStatusLen = sizeof(dwStatus);
BOOL bCancelled = FALSE;
BOOL bTempfile = FALSE;
BOOL bCab = FALSE;
HINTERNET hOpen = NULL;
HINTERNET hFile = NULL;
HANDLE hOut = INVALID_HANDLE_VALUE;
unsigned char lpBuffer[4096];
const LPWSTR lpszAgent = L"RApps/1.0";
URL_COMPONENTS urlComponents;
size_t urlLength, filenameLength;
/* build the path for the download */
p = wcsrchr(AppInfo->szUrlDownload, L'/');
q = wcsrchr(AppInfo->szUrlDownload, L'?');
/* do we have a final slash separator? */
if (!p)
goto end;
/* prepare the tentative length of the filename, maybe we've to remove part of it later on */
filenameLength = wcslen(p) * sizeof(WCHAR);
/* do we have query arguments in the target URL after the filename? account for them
(e.g. https://example.org/myfile.exe?no_adware_plz) */
if (q && q > p && (q - p) > 0)
filenameLength -= wcslen(q - 1) * sizeof(WCHAR);
/* is this URL an update package for RAPPS? if so store it in a different place */
if (wcscmp(AppInfo->szUrlDownload, APPLICATION_DATABASE_URL) == 0)
{
bCab = TRUE;
if (!GetStorageDirectory(path, _countof(path)))
goto end;
}
else
{
if (FAILED(StringCbCopyW(path, sizeof(path), SettingsInfo.szDownloadDir)))
goto end;
}
/* is the path valid? can we access it? */
if (GetFileAttributesW(path) == INVALID_FILE_ATTRIBUTES)
{
if (!CreateDirectoryW(path, NULL))
goto end;
}
/* append a \ to the provided file system path, and the filename portion from the URL after that */
if (FAILED(StringCbCatW(path, sizeof(path), L"\\")))
goto end;
if (FAILED(StringCbCatNW(path, sizeof(path), p + 1, filenameLength)))
goto end;
/* is the file already there? let's avoid having to download it */
if (!bCab && AppInfo->szSHA1[0] != 0 && GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
{
/* only open it in case of total correctness */
if (VerifyInteg(AppInfo->szSHA1, path))
goto run;
}
/* create an async download context for it */
bTempfile = TRUE;
dl = CreateDl(Context, &bCancelled);
if (dl == NULL)
goto end;
/* FIXME: this should just be using the system-wide proxy settings */
switch(SettingsInfo.Proxy)
{
case 0: /* preconfig */
hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
break;
case 1: /* direct (no proxy) */
hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
break;
case 2: /* use proxy */
hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_PROXY, SettingsInfo.szProxyServer, SettingsInfo.szNoProxyFor, 0);
break;
default: /* preconfig */
hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
break;
}
if (!hOpen)
goto end;
hFile = InternetOpenUrlW(hOpen, AppInfo->szUrlDownload, NULL, 0, INTERNET_FLAG_PRAGMA_NOCACHE | INTERNET_FLAG_KEEP_CONNECTION, 0);
if (!hFile)
goto end;
if (!HttpQueryInfoW(hFile, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &dwStatus, &dwStatusLen, NULL))
goto end;
if(dwStatus != HTTP_STATUS_OK)
{
WCHAR szMsgText[MAX_STR_LEN];
if (!LoadStringW(hInst, IDS_UNABLE_TO_DOWNLOAD, szMsgText, sizeof(szMsgText) / sizeof(WCHAR)))
goto end;
MessageBoxW(hMainWnd, szMsgText, NULL, MB_OK | MB_ICONERROR);
goto end;
}
dwStatusLen = sizeof(dwStatus);
memset(&urlComponents, 0, sizeof(urlComponents));
urlComponents.dwStructSize = sizeof(urlComponents);
if(FAILED(StringCbLengthW(AppInfo->szUrlDownload, sizeof(AppInfo->szUrlDownload), &urlLength)))
goto end;
urlLength /= sizeof(WCHAR);
urlComponents.dwSchemeLength = urlLength + 1;
urlComponents.lpszScheme = malloc(urlComponents.dwSchemeLength * sizeof(WCHAR));
urlComponents.dwHostNameLength = urlLength + 1;
urlComponents.lpszHostName = malloc(urlComponents.dwHostNameLength * sizeof(WCHAR));
if(!InternetCrackUrlW(AppInfo->szUrlDownload, urlLength+1, ICU_DECODE | ICU_ESCAPE, &urlComponents))
goto end;
if(urlComponents.nScheme == INTERNET_SCHEME_HTTP || urlComponents.nScheme == INTERNET_SCHEME_HTTPS)
HttpQueryInfo(hFile, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, &dwContentLen, &dwStatus, 0);
if(urlComponents.nScheme == INTERNET_SCHEME_FTP)
dwContentLen = FtpGetFileSize(hFile, &dwStatus);
#ifdef USE_CERT_PINNING
/* are we using HTTPS to download the RAPPS update package? check if the certificate is original */
if ((urlComponents.nScheme == INTERNET_SCHEME_HTTPS) &&
(wcscmp(AppInfo->szUrlDownload, APPLICATION_DATABASE_URL) == 0) &&
(!CertIsValid(hOpen, urlComponents.lpszHostName)))
{
WCHAR szMsgText[MAX_STR_LEN];
if (!LoadStringW(hInst, IDS_CERT_DOES_NOT_MATCH, szMsgText, sizeof(szMsgText) / sizeof(WCHAR)))
goto end;
MessageBoxW(Dlg, szMsgText, NULL, MB_OK | MB_ICONERROR);
goto end;
}
#endif
free(urlComponents.lpszScheme);
free(urlComponents.lpszHostName);
hOut = CreateFileW(path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL);
if (hOut == INVALID_HANDLE_VALUE)
goto end;
do
{
if (!InternetReadFile(hFile, lpBuffer, _countof(lpBuffer), &dwBytesRead)) goto end;
if (!WriteFile(hOut, &lpBuffer[0], dwBytesRead, &dwBytesWritten, NULL)) goto end;
dwCurrentBytesRead += dwBytesRead;
IBindStatusCallback_OnProgress(dl, dwCurrentBytesRead, dwContentLen, 0, AppInfo->szUrlDownload);
}
while (dwBytesRead && !bCancelled);
CloseHandle(hOut);
hOut = INVALID_HANDLE_VALUE;
if (bCancelled)
goto end;
/* if this thing isn't a RAPPS update and it has a SHA-1 checksum
verify its integrity by using the native advapi32.A_SHA1 functions */
if (!bCab && AppInfo->szSHA1[0] != 0)
{
WCHAR szMsgText[MAX_STR_LEN];
/* change a few strings in the download dialog to reflect the verification process */
LoadStringW(hInst, IDS_INTEG_CHECK_TITLE, szMsgText, _countof(szMsgText));
SetWindowText(Dlg, szMsgText);
SendMessageW(GetDlgItem(Dlg, IDC_DOWNLOAD_STATUS), WM_SETTEXT, 0, (LPARAM)path);
/* this may take a while, depending on the file size */
if (!VerifyInteg(AppInfo->szSHA1, path))
{
if (!LoadStringW(hInst, IDS_INTEG_CHECK_FAIL, szMsgText, _countof(szMsgText)))
goto end;
MessageBoxW(Dlg, szMsgText, NULL, MB_OK | MB_ICONERROR);
goto end;
}
}
ShowWindow(Dlg, SW_HIDE);
run:
/* run it */
if (!bCab)
ShellExecuteW( NULL, L"open", path, NULL, NULL, SW_SHOWNORMAL );
end:
if (hOut != INVALID_HANDLE_VALUE)
CloseHandle(hOut);
InternetCloseHandle(hFile);
InternetCloseHandle(hOpen);
if (dl)
IBindStatusCallback_Release(dl);
if (bTempfile)
{
if (bCancelled || (SettingsInfo.bDelInstaller && !bCab))
DeleteFileW(path);
}
EndDialog(Dlg, 0);
return 0;
}
_dnode *_scan_vols_tree(
vol_inf *vol,
int *count
)
{
list_entry *del;
list_entry *node;
list_entry *sub;
for ( node = __drives.flink;
node != &__drives
;
)
{
_dnode *root = contain_record(node, _dnode, list);
if ( count )
{
*count += 1;
}
for ( sub = root->root.vols.flink;
sub != &root->root.vols
;
)
{
_dnode *mnt = contain_record(sub, _dnode, list);
if ( count )
{
*count += 1;
}
if (! vol )
{
if (! mnt->exists )
{
del = sub;
sub = sub->flink;
_remove_entry_list(del);
free(del);
continue;
}
} else {
if ( ( wcscmp(mnt->mnt.info.device, vol->device) == 0 ) && (! mnt->exists) )
{
return mnt;
}
}
sub = sub->flink;
}
if (_is_list_empty(sub))
{
del = node;
node = node->flink;
_remove_entry_list(del);
free(del);
continue;
}
node = node->flink;
}
return NULL;
}
// This method receives notification objects.
HRESULT
WmiSink::Indicate(long lObjectCount, IWbemClassObject** ppObjArray)
{
// For each object in the array, extract the object and display the
// information in the object.
for (long i=0; i<lObjectCount; i++)
{
CComVariant vt, vtClass;
ppObjArray[i]->Get(L"InstanceName", 0, &vt, NULL, NULL);
ppObjArray[i]->Get(L"__Class", 0, &vtClass, NULL, NULL);
if (!wcscmp (vtClass.bstrVal, L"MSNdis_StatusMediaDisconnect"))
{
if (m_callback) m_callback->onConnectionDown(vt.bstrVal);
}
else if (!wcscmp (vtClass.bstrVal, L"MSNdis_StatusMediaConnect"))
{
if (m_callback) m_callback->onConnectionUp(vt.bstrVal);
}
// notifications we aren't interested in right now:
//
//else if (!wcscmp (vtClass.bstrVal, L"MSNdis_NotifyAdapterRemoval"))
//{
// bstrLog = (_bstr_t) vt.bstrVal;
// VariantClear (&vt);
// ppObjArray[i]->Get (L"DeviceName", 0, &vt, NULL, NULL);
// bstrLog += (_bstr_t) _T(": ") + (_bstr_t) vt.bstrVal + (_bstr_t) _T(" has been removed");
// displayDlg.LogEvent (bstrLog);
//}
//else if (!wcscmp (vtClass.bstrVal, L"MSNdis_NotifyAdapterArrival"))
//{
// bstrLog = (_bstr_t) vt.bstrVal;
// VariantClear (&vt);
// ppObjArray[i]->Get(L"DeviceName", 0, &vt, NULL, NULL);
// bstrLog += (_bstr_t) _T(": ") + (_bstr_t) vt.bstrVal + (_bstr_t) _T(" has been added");
// displayDlg.LogEvent (bstrLog);
//}
//else if (!wcscmp (vtClass.bstrVal, L"MSNdis_StatusResetStart"))
//{
// bstrLog = (_bstr_t) vt.bstrVal + (_bstr_t) _T(" has begun a reset");
// displayDlg.LogEvent (bstrLog);
//}
//else if (!wcscmp (vtClass.bstrVal, L"MSNdis_StatusResetEnd"))
//{
// bstrLog = (_bstr_t) vt.bstrVal + (_bstr_t) _T(" has finished a reset");
// displayDlg.LogEvent (bstrLog);
//}
//else if (!wcscmp (vtClass.bstrVal, L"MSNdis_NotifyVcArrival"))
//{
// bstrLog = (_bstr_t) _T("VC arrival: ") + (_bstr_t) vt.bstrVal;
// displayDlg.LogEvent (bstrLog);
//}
//else if (!wcscmp (vtClass.bstrVal, L"MSNdis_NotifyVcRemoval"))
//{
// bstrLog = (_bstr_t) _T("VC removal: ") + (_bstr_t) vt.bstrVal;
// displayDlg.LogEvent (bstrLog);
//}
//else if (!wcscmp (vtClass.bstrVal, L"MSNdis_StatusMediaSpecificIndication"))
//{
// ATLTRACE (_T("Media specific indication: %s\n"), (TCHAR *) (_bstr_t) vt.bstrVal);
// VariantClear (&vt);
// ppObjArray[i]->Get (L"NdisStatusMediaSpecificIndication", 0, &vt, NULL, NULL);
// LONG lLowerBound, lUpperBound, j;
// UCHAR ch;
// SafeArrayGetLBound (V_ARRAY (&vt), 1, &lLowerBound);
// SafeArrayGetUBound (V_ARRAY (&vt), 1, &lUpperBound);
// ATLTRACE (" ");
// for (j = lLowerBound; j<= lUpperBound; j++ )
// {
// SafeArrayGetElement (V_ARRAY (&vt), &j, &ch);
// ATLTRACE (_T("%4i"), ch);
// if (((j - lLowerBound) % 8 == 7) && (j <= lUpperBound))
// ATLTRACE (_T("\n"));
// }
//}
//else if (!wcscmp (vtClass.bstrVal, L"MSNdis_StatusProtocolBind"))
//{
// bstrLog = (_bstr_t) vt.bstrVal;
// VariantClear (&vt);
// ppObjArray[i]->Get (L"Transport", 0, &vt, NULL, NULL);
// bstrLog += (_bstr_t) _T(" is now bound to ") + (_bstr_t) vt.bstrVal;
// displayDlg.LogEvent (bstrLog);
//}
//else if (!wcscmp (vtClass.bstrVal, L"MSNdis_StatusProtocolBind"))
//{
// bstrLog = (_bstr_t) vt.bstrVal;
// VariantClear (&vt);
// ppObjArray[i]->Get(L"Transport", 0, &vt, NULL, NULL);
// bstrLog += (_bstr_t) _T(" was unbound from ") + (_bstr_t) vt.bstrVal;
// displayDlg.LogEvent (bstrLog);
//}
//else if (!wcscmp (vtClass.bstrVal, L"MSNdis_StatusLinkSpeedChange"))
//{
// IWbemClassObject* pWMIObj=NULL;
// bstrLog = (_bstr_t) _T("Link speed change ") + (_bstr_t) vt.bstrVal;
// VariantClear (&vt);
// ppObjArray[i]->Get (L"NdisStatusLinkSpeedChange", 0, &vt, NULL, NULL);
// if SUCCEEDED (vt.punkVal->QueryInterface (IID_IWbemClassObject, (void**)&pWMIObj))
// {
// TCHAR szNum[50];
// pWMIObj->Get (L"Inbound", 0, &vt2, NULL, NULL);
// _stprintf (szNum, _T(" Inbound = %u "), vt2.lVal);
// bstrLog += (_bstr_t) szNum;
// VariantClear (&vt2);
// pWMIObj->Get (L"Outbound", 0, &vt2, NULL, NULL);
// _stprintf (szNum, _T(" Outbound = %u "), vt2.lVal);
// bstrLog += (_bstr_t) szNum;
// VariantClear (&vt2);
// pWMIObj->Release ();
// pWMIObj = NULL;
// }
// displayDlg.LogEvent (bstrLog);
//}
VariantClear (&vtClass);
VariantClear (&vt);
}
return WBEM_NO_ERROR;
}
NS_IMETHODIMP nsLookAndFeel::GetMetric(const nsMetricID aID, PRInt32 & aMetric)
{
nsresult res = nsXPLookAndFeel::GetMetric(aID, aMetric);
if (NS_SUCCEEDED(res))
return res;
res = NS_OK;
switch (aID) {
case eMetric_WindowTitleHeight:
aMetric = ::GetSystemMetrics(SM_CYCAPTION);
break;
#ifndef WINCE
case eMetric_WindowBorderWidth:
aMetric = ::GetSystemMetrics(SM_CXFRAME);
break;
case eMetric_WindowBorderHeight:
aMetric = ::GetSystemMetrics(SM_CYFRAME);
break;
#endif
case eMetric_Widget3DBorder:
aMetric = ::GetSystemMetrics(SM_CXEDGE);
break;
case eMetric_TextFieldBorder:
aMetric = 3;
break;
case eMetric_TextFieldHeight:
aMetric = 24;
break;
case eMetric_ButtonHorizontalInsidePaddingNavQuirks:
aMetric = 10;
break;
case eMetric_ButtonHorizontalInsidePaddingOffsetNavQuirks:
aMetric = 8;
break;
case eMetric_CheckboxSize:
aMetric = 12;
break;
case eMetric_RadioboxSize:
aMetric = 12;
break;
case eMetric_TextHorizontalInsideMinimumPadding:
aMetric = 3;
break;
case eMetric_TextVerticalInsidePadding:
aMetric = 0;
break;
case eMetric_TextShouldUseVerticalInsidePadding:
aMetric = 0;
break;
case eMetric_TextShouldUseHorizontalInsideMinimumPadding:
aMetric = 1;
break;
case eMetric_ListShouldUseHorizontalInsideMinimumPadding:
aMetric = 0;
break;
case eMetric_ListHorizontalInsideMinimumPadding:
aMetric = 3;
break;
case eMetric_ListShouldUseVerticalInsidePadding:
aMetric = 0;
break;
case eMetric_ListVerticalInsidePadding:
aMetric = 0;
break;
case eMetric_CaretBlinkTime:
aMetric = (PRInt32)::GetCaretBlinkTime();
break;
case eMetric_CaretWidth:
aMetric = 1;
break;
case eMetric_ShowCaretDuringSelection:
aMetric = 0;
break;
case eMetric_SelectTextfieldsOnKeyFocus:
// Select textfield content when focused by kbd
// used by nsEventStateManager::sTextfieldSelectModel
aMetric = 1;
break;
case eMetric_SubmenuDelay:
// This will default to the Windows' default
// (400ms) on error.
#ifndef WINCE
aMetric = GetSystemParam(SPI_GETMENUSHOWDELAY, 400);
#else
aMetric = 400;
#endif
break;
case eMetric_MenusCanOverlapOSBar:
// we want XUL popups to be able to overlap the task bar.
aMetric = 1;
break;
#ifndef WINCE
case eMetric_DragThresholdX:
// The system metric is the number of pixels at which a drag should
// start. Our look and feel metric is the number of pixels you can
// move before starting a drag, so subtract 1.
aMetric = ::GetSystemMetrics(SM_CXDRAG) - 1;
break;
case eMetric_DragThresholdY:
aMetric = ::GetSystemMetrics(SM_CYDRAG) - 1;
break;
case eMetric_UseAccessibilityTheme:
// High contrast is a misnomer under Win32 -- any theme can be used with it,
// e.g. normal contrast with large fonts, low contrast, etc.
// The high contrast flag really means -- use this theme and don't override it.
HIGHCONTRAST contrastThemeInfo;
contrastThemeInfo.cbSize = sizeof(contrastThemeInfo);
::SystemParametersInfo(SPI_GETHIGHCONTRAST, 0, &contrastThemeInfo, 0);
aMetric = ((contrastThemeInfo.dwFlags & HCF_HIGHCONTRASTON) != 0);
break;
case eMetric_IsScreenReaderActive:
// This will default to the Windows' default
// (off by default) on error.
aMetric = GetSystemParam(SPI_GETSCREENREADER, 0);
break;
#endif
case eMetric_ScrollArrowStyle:
aMetric = eMetric_ScrollArrowStyleSingle;
break;
case eMetric_ScrollSliderStyle:
aMetric = eMetric_ScrollThumbStyleProportional;
break;
case eMetric_TreeOpenDelay:
aMetric = 1000;
break;
case eMetric_TreeCloseDelay:
aMetric = 0;
break;
case eMetric_TreeLazyScrollDelay:
aMetric = 150;
break;
case eMetric_TreeScrollDelay:
aMetric = 100;
break;
case eMetric_TreeScrollLinesMax:
aMetric = 3;
break;
case eMetric_WindowsClassic:
#ifndef WINCE
aMetric = !nsUXThemeData::IsAppThemed();
#else
aMetric = 0;
#endif
break;
case eMetric_TouchEnabled:
aMetric = 0;
#ifndef WINCE
PRInt32 touchCapabilities;
touchCapabilities = ::GetSystemMetrics(SM_DIGITIZER);
if ((touchCapabilities & NID_READY) &&
(touchCapabilities & (NID_EXTERNAL_TOUCH | NID_INTEGRATED_TOUCH))) {
aMetric = 1;
}
#elif defined(WINCE_WINDOWS_MOBILE)
WCHAR platformType[MAX_PATH];
SystemParametersInfo(SPI_GETPLATFORMTYPE, sizeof(platformType),
platformType, 0);
if (!wcscmp(platformType, L"PocketPC"))
aMetric = 1;
#endif
break;
case eMetric_WindowsDefaultTheme:
aMetric = 0;
#ifndef WINCE
if (nsUXThemeData::getCurrentThemeName) {
WCHAR themeFileName[MAX_PATH + 1] = {L'\0'};
HRESULT hresult =
nsUXThemeData::getCurrentThemeName(themeFileName, MAX_PATH,
NULL, 0, NULL, 0);
// WIN2K and earlier will not have getCurrentThemeName defined, so
// they will never make it this far. Unless we want to save 6.0
// users a handful of clock cycles by skipping checks for the
// 5.x themes (or vice-versa), we can use a single loop for all
// the different Windows versions.
if (hresult == S_OK && nsWindow::GetWindowsVersion() <= WIN7_VERSION) {
LPCWSTR defThemes[] = {
L"luna.msstyles",
L"royale.msstyles",
L"zune.msstyles",
L"aero.msstyles"
};
LPWSTR curTheme = wcsrchr(themeFileName, L'\\');
curTheme = curTheme ? curTheme + 1 : themeFileName;
for (int i = 0; i < NS_ARRAY_LENGTH(defThemes); ++i) {
if (!lstrcmpiW(curTheme, defThemes[i])) {
aMetric = 1;
}
}
} else {
res = NS_ERROR_NOT_IMPLEMENTED;
}
}
else
#endif /* WINCE */
{
res = NS_ERROR_NOT_IMPLEMENTED;
}
break;
case eMetric_MacGraphiteTheme:
case eMetric_MaemoClassic:
aMetric = 0;
res = NS_ERROR_NOT_IMPLEMENTED;
break;
case eMetric_DWMCompositor:
#ifndef WINCE
aMetric = nsUXThemeData::sHaveCompositor;
#else
aMetric = 0;
#endif
break;
case eMetric_AlertNotificationOrigin:
aMetric = 0;
#ifndef WINCE
if (gSHAppBarMessage)
{
// Get task bar window handle
HWND shellWindow = FindWindowW(L"Shell_TrayWnd", NULL);
if (shellWindow != NULL)
{
// Determine position
APPBARDATA appBarData;
appBarData.hWnd = shellWindow;
appBarData.cbSize = sizeof(appBarData);
if (gSHAppBarMessage(ABM_GETTASKBARPOS, &appBarData))
{
// Set alert origin as a bit field - see nsILookAndFeel.h
// 0 represents bottom right, sliding vertically.
switch(appBarData.uEdge)
{
case ABE_LEFT:
aMetric = NS_ALERT_HORIZONTAL | NS_ALERT_LEFT;
break;
case ABE_RIGHT:
aMetric = NS_ALERT_HORIZONTAL;
break;
case ABE_TOP:
aMetric = NS_ALERT_TOP;
// fall through for the right-to-left handling.
case ABE_BOTTOM:
// If the task bar is right-to-left,
// move the origin to the left
if (::GetWindowLong(shellWindow, GWL_EXSTYLE) &
WS_EX_LAYOUTRTL)
aMetric |= NS_ALERT_LEFT;
break;
}
}
}
}
#endif // WINCE
break;
case eMetric_IMERawInputUnderlineStyle:
case eMetric_IMEConvertedTextUnderlineStyle:
aMetric = NS_UNDERLINE_STYLE_DASHED;
break;
case eMetric_IMESelectedRawTextUnderlineStyle:
case eMetric_IMESelectedConvertedTextUnderline:
aMetric = NS_UNDERLINE_STYLE_NONE;
break;
case eMetric_SpellCheckerUnderlineStyle:
aMetric = NS_UNDERLINE_STYLE_WAVY;
break;
default:
aMetric = 0;
res = NS_ERROR_FAILURE;
}
return res;
}
HRESULT CXMLControlsHandler::GetPathNodeValue(BSTR path, BSTR* pVal)
{
*pVal = NULL;
if (!m_bAnimation)
{
long ncount;
m_viewGroup->GetSelectedCount(&ncount);
CComBSTR value;
for (int i = 0; i < ncount; i++)
{
CComPtr<IESelectedElement> selectedElement;
m_viewGroup->GetSelectedElementN(i, &selectedElement);
CComPtr<IEElement> eElement;
selectedElement->get_eElement(&eElement);
CComPtr<ILDOMElement> domElement;
eElement->get_domElement(&domElement);
CComBSTR value2;
::GetPathNodeValue(domElement, path, &value2);
if (i == 0)
{
value = value2;
}
else if (cmpbstr(value, value2))
{
value.Empty();
break;
}
}
*pVal = value.Detach();
}
else
{
long ncount;
m_viewGroup->GetSelectedCount(&ncount);
for (int i = 0; i < ncount; i++)
{
CComPtr<IESelectedElement> selectedElement;
m_viewGroup->GetSelectedElementN(i, &selectedElement);
CComPtr<IEElement> eElement;
selectedElement->get_eElement(&eElement);
CComPtr<ILDOMElement> domElement;
eElement->get_domElement(&domElement);
CComBSTR attributeName;
domElement->getAttribute(L"attributeName", &attributeName);
if (!wcscmp(attributeName, &path[1]))
{
CComQIPtr<IESelectedAnimationElement> selectedAnimationElement = selectedElement;
//if (wcscmp(attributeName,
if (selectedAnimationElement)//TRUE) // TODO
{
//CComQIPtr<ILSMILAnimationTarget> animationTarget = animationTarget;
CComQIPtr<ILAnimateXXX> animateXXX = domElement;
long ncount;
selectedAnimationElement->GetSelectedKeyTimesCount(&ncount);
CComBSTR value;
for (int i = 0; i < ncount; i++)
{
long keyFrame;
selectedAnimationElement->GetKeyTimeSelected(i, &keyFrame);
//CComPtr<ILSMILXMLAttr> attr;
//animationTarget->animatableXMLAttrItemByName(L"", &attribute);
CComPtr<ILSMILAttributeValue> attributeValue;
animateXXX->GetValue(keyFrame, &attributeValue);
CComBSTR value2;
if (attributeValue)
attributeValue->getStringValue(&value2);
if (i == 0)
{
value = value2;
}
else if (cmpbstr(value, value2))
{
value.Empty();
break;
}
}
*pVal = value.Detach();
return S_OK;
}
}
}
}
return S_OK;
}
// This function does I/O
static void tokenize( const wchar_t * const buff, std::vector<int> &color, const int pos, wcstring_list_t *error, const wcstring &working_directory, const env_vars &vars) {
ASSERT_IS_BACKGROUND_THREAD();
wcstring cmd;
int had_cmd=0;
wcstring last_cmd;
int len;
int accept_switches = 1;
int use_function = 1;
int use_command = 1;
int use_builtin = 1;
CHECK( buff, );
len = wcslen(buff);
if( !len )
return;
std::fill(color.begin(), color.end(), -1);
tokenizer tok;
for( tok_init( &tok, buff, TOK_SHOW_COMMENTS | TOK_SQUASH_ERRORS );
tok_has_next( &tok );
tok_next( &tok ) )
{
int last_type = tok_last_type( &tok );
switch( last_type )
{
case TOK_STRING:
{
if( had_cmd )
{
/*Parameter */
wchar_t *param = tok_last( &tok );
if( param[0] == L'-' )
{
if (wcscmp( param, L"--" ) == 0 )
{
accept_switches = 0;
color.at(tok_get_pos( &tok )) = HIGHLIGHT_PARAM;
}
else if( accept_switches )
{
if( complete_is_valid_option( last_cmd.c_str(), param, error, false /* no autoload */ ) )
color.at(tok_get_pos( &tok )) = HIGHLIGHT_PARAM;
else
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
}
else
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_PARAM;
}
}
else
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_PARAM;
}
if( cmd == L"cd" )
{
wcstring dir = tok_last( &tok );
if (expand_one(dir, EXPAND_SKIP_CMDSUBST))
{
int is_help = string_prefixes_string(dir, L"--help") || string_prefixes_string(dir, L"-h");
if( !is_help && ! is_potential_cd_path(dir, working_directory, NULL))
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
}
}
}
/* Highlight the parameter. highlight_param wants to write one more color than we have characters (hysterical raisins) so allocate one more in the vector. But don't copy it back. */
const wcstring param_str = param;
int tok_pos = tok_get_pos(&tok);
std::vector<int>::const_iterator where = color.begin() + tok_pos;
std::vector<int> subcolors(where, where + param_str.size());
subcolors.push_back(-1);
highlight_param(param_str, subcolors, pos-tok_pos, error);
/* Copy the subcolors back into our colors array */
std::copy(subcolors.begin(), subcolors.begin() + param_str.size(), color.begin() + tok_pos);
}
else
{
/*
Command. First check that the command actually exists.
*/
cmd = tok_last( &tok );
bool expanded = expand_one(cmd, EXPAND_SKIP_CMDSUBST | EXPAND_SKIP_VARIABLES);
if (! expanded || has_expand_reserved(cmd.c_str()))
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
}
else
{
bool is_cmd = false;
int is_subcommand = 0;
int mark = tok_get_pos( &tok );
color.at(tok_get_pos( &tok )) = HIGHLIGHT_COMMAND;
if( parser_keywords_is_subcommand( cmd ) )
{
int sw;
if( cmd == L"builtin")
{
use_function = 0;
use_command = 0;
use_builtin = 1;
}
else if( cmd == L"command")
{
use_command = 1;
use_function = 0;
use_builtin = 0;
}
tok_next( &tok );
sw = parser_keywords_is_switch( tok_last( &tok ) );
if( !parser_keywords_is_block( cmd ) &&
sw == ARG_SWITCH )
{
/*
The 'builtin' and 'command' builtins
are normally followed by another
command, but if they are invoked
with a switch, they aren't.
*/
use_command = 1;
use_function = 1;
use_builtin = 2;
}
else
{
if( sw == ARG_SKIP )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_PARAM;
mark = tok_get_pos( &tok );
}
is_subcommand = 1;
}
tok_set_pos( &tok, mark );
}
if( !is_subcommand )
{
/*
OK, this is a command, it has been
successfully expanded and everything
looks ok. Lets check if the command
exists.
*/
/*
First check if it is a builtin or
function, since we don't have to stat
any files for that
*/
if (! is_cmd && use_builtin )
is_cmd = builtin_exists( cmd );
if (! is_cmd && use_function )
is_cmd = function_exists_no_autoload( cmd, vars );
/*
Moving on to expensive tests
*/
/*
Check if this is a regular command
*/
if (! is_cmd && use_command )
{
wcstring tmp;
is_cmd = path_get_path_string( cmd, tmp, vars );
}
/* Maybe it is a path for a implicit cd command. */
if (! is_cmd)
{
if (use_builtin || (use_function && function_exists_no_autoload( L"cd", vars)))
is_cmd = path_can_be_implicit_cd(cmd, NULL, working_directory.c_str());
}
if( is_cmd )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_COMMAND;
}
else
{
if( error ) {
error->push_back(format_string(L"Unknown command \'%ls\'", cmd.c_str()));
}
color.at(tok_get_pos( &tok )) = (HIGHLIGHT_ERROR);
}
had_cmd = 1;
}
if( had_cmd )
{
last_cmd = tok_last( &tok );
}
}
}
break;
}
case TOK_REDIRECT_NOCLOB:
case TOK_REDIRECT_OUT:
case TOK_REDIRECT_IN:
case TOK_REDIRECT_APPEND:
case TOK_REDIRECT_FD:
{
if( !had_cmd )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
if( error )
error->push_back(L"Redirection without a command");
break;
}
wcstring target_str;
const wchar_t *target=NULL;
color.at(tok_get_pos( &tok )) = HIGHLIGHT_REDIRECTION;
tok_next( &tok );
/*
Check that we are redirecting into a file
*/
switch( tok_last_type( &tok ) )
{
case TOK_STRING:
{
target_str = tok_last( &tok );
if (expand_one(target_str, EXPAND_SKIP_CMDSUBST)) {
target = target_str.c_str();
}
/*
Redirect filename may contain a cmdsubst.
If so, it will be ignored/not flagged.
*/
}
break;
default:
{
size_t pos = tok_get_pos(&tok);
if (pos < color.size()) {
color.at(pos) = HIGHLIGHT_ERROR;
}
if( error )
error->push_back(L"Invalid redirection");
}
}
if( target != 0 )
{
wcstring dir = target;
size_t slash_idx = dir.find_last_of(L'/');
struct stat buff;
/*
If file is in directory other than '.', check
that the directory exists.
*/
if( slash_idx != wcstring::npos )
{
dir.resize(slash_idx);
if( wstat( dir, &buff ) == -1 )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
if( error )
error->push_back(format_string(L"Directory \'%ls\' does not exist", dir.c_str()));
}
}
/*
If the file is read from or appended to, check
if it exists.
*/
if( last_type == TOK_REDIRECT_IN ||
last_type == TOK_REDIRECT_APPEND )
{
if( wstat( target, &buff ) == -1 )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
if( error )
error->push_back(format_string(L"File \'%ls\' does not exist", target));
}
}
if( last_type == TOK_REDIRECT_NOCLOB )
{
if( wstat( target, &buff ) != -1 )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
if( error )
error->push_back(format_string(L"File \'%ls\' exists", target));
}
}
}
break;
}
case TOK_PIPE:
case TOK_BACKGROUND:
{
if( had_cmd )
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_END;
had_cmd = 0;
use_command = 1;
use_function = 1;
use_builtin = 1;
accept_switches = 1;
}
else
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
if( error )
error->push_back(L"No job to put in background" );
}
break;
}
case TOK_END:
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_END;
had_cmd = 0;
use_command = 1;
use_function = 1;
use_builtin = 1;
accept_switches = 1;
break;
}
case TOK_COMMENT:
{
color.at(tok_get_pos( &tok )) = HIGHLIGHT_COMMENT;
break;
}
case TOK_ERROR:
default:
{
/*
If the tokenizer reports an error, highlight it as such.
*/
if( error )
error->push_back(tok_last( &tok));
color.at(tok_get_pos( &tok )) = HIGHLIGHT_ERROR;
break;
}
}
}
tok_destroy( &tok );
}
int main()
{
// mbstate_t comes from the underlying C library; it is defined (in C99) as:
// a complete object type other than an array type that can hold the conversion
// state information necessary to convert between sequences of multibyte
// characters and wide characters
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmissing-braces"
#endif
mbstate_t mb = {0};
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
size_t s = 0;
tm *tm = 0;
wint_t w = 0;
::FILE* fp = 0;
#ifdef __APPLE__
__darwin_va_list va;
#else
__builtin_va_list va;
#endif
char* ns = 0;
wchar_t* ws = 0;
static_assert((std::is_same<decltype(fwprintf(fp, L"")), int>::value), "");
static_assert((std::is_same<decltype(fwscanf(fp, L"")), int>::value), "");
static_assert((std::is_same<decltype(swprintf(ws, s, L"")), int>::value), "");
static_assert((std::is_same<decltype(swscanf(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(vfwprintf(fp, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vfwscanf(fp, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vswprintf(ws, s, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vswscanf(L"", L"", va)), int>::value), "");
static_assert((std::is_same<decltype(fgetwc(fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(fgetws(ws, 0, fp)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(fputwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(fputws(L"", fp)), int>::value), "");
static_assert((std::is_same<decltype(fwide(fp, 0)), int>::value), "");
static_assert((std::is_same<decltype(getwc(fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(putwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(ungetwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(wcstod(L"", (wchar_t**)0)), double>::value), "");
static_assert((std::is_same<decltype(wcstof(L"", (wchar_t**)0)), float>::value), "");
static_assert((std::is_same<decltype(wcstold(L"", (wchar_t**)0)), long double>::value), "");
static_assert((std::is_same<decltype(wcstol(L"", (wchar_t**)0, 0)), long>::value), "");
static_assert((std::is_same<decltype(wcstoll(L"", (wchar_t**)0, 0)), long long>::value), "");
static_assert((std::is_same<decltype(wcstoul(L"", (wchar_t**)0, 0)), unsigned long>::value), "");
static_assert((std::is_same<decltype(wcstoull(L"", (wchar_t**)0, 0)), unsigned long long>::value), "");
static_assert((std::is_same<decltype(wcscpy(ws, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsncpy(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscat(ws, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsncat(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscmp(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(wcscoll(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(wcsncmp(L"", L"", s)), int>::value), "");
static_assert((std::is_same<decltype(wcsxfrm(ws, L"", s)), size_t>::value), "");
static_assert((std::is_same<decltype(wcschr((wchar_t*)0, L' ')), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscspn(L"", L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcslen(L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcspbrk((wchar_t*)0, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsrchr((wchar_t*)0, L' ')), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsspn(L"", L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcsstr((wchar_t*)0, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcstok(ws, L"", (wchar_t**)0)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemchr((wchar_t*)0, L' ', s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemcmp(L"", L"", s)), int>::value), "");
static_assert((std::is_same<decltype(wmemcpy(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemmove(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemset(ws, L' ', s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsftime(ws, s, L"", tm)), size_t>::value), "");
static_assert((std::is_same<decltype(btowc(0)), wint_t>::value), "");
static_assert((std::is_same<decltype(wctob(w)), int>::value), "");
static_assert((std::is_same<decltype(mbsinit(&mb)), int>::value), "");
static_assert((std::is_same<decltype(mbrlen("", s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(mbrtowc(ws, "", s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(wcrtomb(ns, L' ', &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(mbsrtowcs(ws, (const char**)0, s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(wcsrtombs(ns, (const wchar_t**)0, s, &mb)), size_t>::value), "");
// These tests fail on systems whose C library doesn't provide a correct overload
// set for wcschr, wcspbrk, wcsrchr, wcsstr, and wmemchr, unless the compiler is
// a suitably recent version of Clang.
#if !defined(__APPLE__) || defined(_LIBCPP_PREFERRED_OVERLOAD)
static_assert((std::is_same<decltype(wcschr((const wchar_t*)0, L' ')), const wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcspbrk((const wchar_t*)0, L"")), const wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsrchr((const wchar_t*)0, L' ')), const wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsstr((const wchar_t*)0, L"")), const wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemchr((const wchar_t*)0, L' ', s)), const wchar_t*>::value), "");
#endif
#ifndef _LIBCPP_HAS_NO_STDIN
static_assert((std::is_same<decltype(getwchar()), wint_t>::value), "");
static_assert((std::is_same<decltype(vwscanf(L"", va)), int>::value), "");
static_assert((std::is_same<decltype(wscanf(L"")), int>::value), "");
#endif
#ifndef _LIBCPP_HAS_NO_STDOUT
static_assert((std::is_same<decltype(putwchar(L' ')), wint_t>::value), "");
static_assert((std::is_same<decltype(vwprintf(L"", va)), int>::value), "");
static_assert((std::is_same<decltype(wprintf(L"")), int>::value), "");
#endif
}
CResourceCompilerHelper::ERcCallResult CResourceCompilerHelper::CallResourceCompiler(
const char* szFileName,
const char* szAdditionalSettings,
IResourceCompilerListener* listener,
bool bMayShowWindow,
CResourceCompilerHelper::ERcExePath rcExePath,
bool bSilent,
bool bNoUserDialog,
const wchar_t* szWorkingDirectory,
const wchar_t* szRootPath)
{
// make command for execution
SettingsManagerHelpers::CFixedString<wchar_t, MAX_PATH*3> wRemoteCmdLine;
if (!szAdditionalSettings)
{
szAdditionalSettings = "";
}
wchar_t szRemoteDirectory[512];
{
wchar_t pathBuffer[512];
switch (rcExePath)
{
case eRcExePath_registry:
GetRootPathUtf16(true, SettingsManagerHelpers::CWCharBuffer(pathBuffer, sizeof(pathBuffer)));
break;
case eRcExePath_settingsManager:
GetRootPathUtf16(false, SettingsManagerHelpers::CWCharBuffer(pathBuffer, sizeof(pathBuffer)));
break;
case eRcExePath_currentFolder:
wcscpy(pathBuffer, L".");
break;
case eRcExePath_customPath:
wcscpy(pathBuffer, szRootPath);
break;
default:
return eRcCallResult_notFound;
}
if (!pathBuffer[0])
{
wcscpy(pathBuffer, L".");
}
swprintf_s(szRemoteDirectory, L"%s/Bin32/rc", pathBuffer);
}
if (!szFileName)
{
wRemoteCmdLine.appendAscii("\"");
wRemoteCmdLine.append(szRemoteDirectory);
wRemoteCmdLine.appendAscii("/rc.exe\" /userdialog=0 ");
wRemoteCmdLine.appendAscii(szAdditionalSettings);
}
else
{
wRemoteCmdLine.appendAscii("\"");
wRemoteCmdLine.append(szRemoteDirectory);
wRemoteCmdLine.appendAscii("/rc.exe\" \"");
wRemoteCmdLine.appendAscii(szFileName);
wRemoteCmdLine.appendAscii("\" ");
wRemoteCmdLine.appendAscii(bNoUserDialog ? "/userdialog=0 " : "/userdialog=1 ");
wRemoteCmdLine.appendAscii(szAdditionalSettings);
}
// Create a pipe to read the stdout of the RC.
SECURITY_ATTRIBUTES saAttr;
::memset(&saAttr, 0, sizeof(saAttr));
saAttr.bInheritHandle = TRUE;
saAttr.lpSecurityDescriptor = 0;
HANDLE hChildStdOutRd, hChildStdOutWr;
CreatePipe(&hChildStdOutRd, &hChildStdOutWr, &saAttr, 0);
SetHandleInformation(hChildStdOutRd, HANDLE_FLAG_INHERIT, 0); // Need to do this according to MSDN
HANDLE hChildStdInRd, hChildStdInWr;
CreatePipe(&hChildStdInRd, &hChildStdInWr, &saAttr, 0);
SetHandleInformation(hChildStdInWr, HANDLE_FLAG_INHERIT, 0); // Need to do this according to MSDN
STARTUPINFOW si;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
si.dwX = 100;
si.dwY = 100;
si.hStdError = hChildStdOutWr;
si.hStdOutput = hChildStdOutWr;
si.hStdInput = hChildStdInRd;
si.dwFlags = STARTF_USEPOSITION | STARTF_USESTDHANDLES;
PROCESS_INFORMATION pi;
ZeroMemory(&pi, sizeof(pi));
bool bShowWindow = false;
{
wchar_t buffer[20];
g_pSettingsManager->GetValueByRef("ShowWindow", SettingsManagerHelpers::CWCharBuffer(buffer, sizeof(buffer)));
bShowWindow = (wcscmp(buffer, L"true") == 0);
}
if (!CreateProcessW(
NULL, // No module name (use command line).
const_cast<wchar_t*>(wRemoteCmdLine.c_str()), // Command line.
NULL, // Process handle not inheritable.
NULL, // Thread handle not inheritable.
TRUE, // Set handle inheritance to TRUE.
(bMayShowWindow && bShowWindow) ? 0 : CREATE_NO_WINDOW, // creation flags.
NULL, // Use parent's environment block.
szWorkingDirectory?szWorkingDirectory:szRemoteDirectory, // Set starting directory.
&si, // Pointer to STARTUPINFO structure.
&pi )) // Pointer to PROCESS_INFORMATION structure.
{
/*
This code block is commented out instead of being deleted because it's
good to have at hand for a debugging session.
const size_t charsInMessageBuffer = 32768; // msdn about FormatMessage(): "The output buffer cannot be larger than 64K bytes."
wchar_t szMessageBuffer[charsInMessageBuffer] = L"";
FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0, szMessageBuffer, charsInMessageBuffer, NULL);
GetCurrentDirectoryW(charsInMessageBuffer, szMessageBuffer);
*/
if (!bSilent)
{
MessageBoxA(0, "ResourceCompiler was not found.\n\nPlease verify CryENGINE RootPath.", "Error", MB_ICONERROR|MB_OK);
}
return eRcCallResult_notFound;
}
// Close the pipe that writes to the child process, since we don't actually have any input for it.
CloseHandle(hChildStdInWr);
// Read all the output from the child process.
CloseHandle(hChildStdOutWr);
ResourceCompilerLineHandler lineHandler(listener);
LineStreamBuffer lineBuffer(&lineHandler, &ResourceCompilerLineHandler::HandleLine);
for (;;)
{
char buffer[2048];
DWORD bytesRead;
if (!ReadFile(hChildStdOutRd, buffer, sizeof(buffer), &bytesRead, NULL) || (bytesRead == 0))
{
break;
}
lineBuffer.HandleText(buffer, bytesRead);
}
// Wait until child process exits.
WaitForSingleObject(pi.hProcess, INFINITE);
bool ok = true;
DWORD exitCode = 1;
{
if ((GetExitCodeProcess(pi.hProcess, &exitCode) == 0) || (exitCode != 0))
{
ok = false;
}
}
// Close process and thread handles.
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
if (exitCode == eRcExitCode_Crash)
{
return eRcCallResult_crash;
}
if (lineBuffer.IsTruncated())
{
return eRcCallResult_error;
}
return ok ? eRcCallResult_success : eRcCallResult_error;
}