int ProcessHDDIsInActive(std::wstring& disk)
{
WCHAR letter[SIZELETTERWCHAR] = {0};
CreateLetterFromVolume(disk.c_str(), letter);
int result = 0;
map<wstring, wstring>::iterator it = ListMutex->find(wstring(letter));
map<wstring, wstring>::iterator itTimer;
if (it != ListMutex->end()){
HANDLE waitTimer = INVALID_HANDLE_VALUE;
EnterCriticalSection(CriticalSection);
itTimer = ListTimers->find(wstring(letter));
LeaveCriticalSection(CriticalSection);
if(itTimer != ListTimers->end())
{
waitTimer = OpenWaitableTimer(TIMER_ALL_ACCESS, FALSE, itTimer->second.c_str());
if(waitTimer != INVALID_HANDLE_VALUE)
CancelWaitableTimer(waitTimer);
ListTimers->erase(itTimer);
CloseHandle(waitTimer);
}
ListMutex->erase(it);
map<wstring, Operations>::iterator itOps = ListCurrentBusyDisks->find(wstring(letter));
if(itOps != ListCurrentBusyDisks->end())
ListCurrentBusyDisks->erase(itOps);
}
else
result = 1;
return result;
}
// Uses jpg as the extension
void TimeToSubDirectoryAndFilename(SYSTEMTIME st, wstring& subDirectory, wstring& filename, wstring const& ext = L".jpg")
{
WCHAR buffer[100];
swprintf_s(buffer, L"\\%04d%02d%02d\\", st.wYear, st.wMonth, st.wDay);
subDirectory = wstring(buffer);
swprintf_s(buffer, L"%02d%02d%02d", st.wHour, st.wMinute, st.wSecond);
filename = wstring(buffer) + ext;
}
TEST_F(SorterTest, TestCaseInsensitiveStringCompares)
{
// Check case insensitive string compares.
EXPECT_EQ(0, CaseInsensitiveCmp(wstring(L"blah"), wstring(L"Blah")));
EXPECT_EQ(0, CaseInsensitiveCmp(wstring(L"foo"), wstring(L"foo")));
EXPECT_EQ(-1, CaseInsensitiveCmp(wstring(L"meep"), wstring(L"meepz")));
EXPECT_EQ(-1, CaseInsensitiveCmp(wstring(L"meep"), wstring(L"meep baz")));
EXPECT_EQ(1, CaseInsensitiveCmp(wstring(L"abc"), wstring(L"ABB")));
}
TEST(StringOperationsTest, ConvertToWidechar)
{
wstring wideString;
utf8ToWideChar("Teststring", wideString);
EXPECT_TRUE(wstring(L"Teststring") == wideString);
utf8ToWideChar("Trentemøller", wideString);
EXPECT_TRUE(wstring(L"Trentemøller") == wideString);
}
static wstring descriptionSuitableForTestResult(IWebError* error, unsigned long identifier)
{
wstring result = L"<NSError ";
BSTR domainSTR;
if (FAILED(error->domain(&domainSTR)))
return wstring();
wstring domain = wstringFromBSTR(domainSTR);
::SysFreeString(domainSTR);
int code;
if (FAILED(error->code(&code)))
return wstring();
if (domain == L"CFURLErrorDomain") {
domain = L"NSURLErrorDomain";
// Convert kCFURLErrorUnknown to NSURLErrorUnknown
if (code == -998)
code = -1;
} else if (domain == L"kCFErrorDomainWinSock") {
domain = L"NSURLErrorDomain";
// Convert the winsock error code to an NSURLError code.
if (code == WSAEADDRNOTAVAIL)
code = -1004; // NSURLErrorCannotConnectToHose;
}
result += L"domain " + domain;
result += L", code " + wstringFromInt(code);
BSTR failingURLSTR;
if (FAILED(error->failingURL(&failingURLSTR)))
return wstring();
wstring failingURL;
// If the error doesn't have a failing URL, we fake one by using the URL the resource had
// at creation time. This seems to work fine for now.
// See <rdar://problem/5064234> CFErrors should have failingURL key.
if (failingURLSTR)
failingURL = wstringFromBSTR(failingURLSTR);
else
failingURL = descriptionSuitableForTestResult(identifier);
::SysFreeString(failingURLSTR);
result += L", failing URL \"" + urlSuitableForTestResult(failingURL) + L"\">";
return result;
}
JSStringRef AccessibilityUIElement::role()
{
if (!m_element)
return JSStringCreateWithCharacters(0, 0);
VARIANT vRole;
if (FAILED(m_element->get_accRole(self(), &vRole)))
return JSStringCreateWithCharacters(0, 0);
ASSERT(V_VT(&vRole) == VT_I4 || V_VT(&vRole) == VT_BSTR);
wstring result;
if (V_VT(&vRole) == VT_I4) {
unsigned roleTextLength = ::GetRoleText(V_I4(&vRole), 0, 0) + 1;
Vector<TCHAR> roleText(roleTextLength);
::GetRoleText(V_I4(&vRole), roleText.data(), roleTextLength);
result = roleText.data();
} else if (V_VT(&vRole) == VT_BSTR)
result = wstring(V_BSTR(&vRole), ::SysStringLen(V_BSTR(&vRole)));
::VariantClear(&vRole);
return JSStringCreateWithCharacters(result.data(), result.length());
}
static bool followShortcuts(wstring& path)
{
if (PathFileExists(path.c_str()))
return true;
// Do we have a shortcut?
wstring linkPath = path;
linkPath.append(TEXT(".lnk"));
if (!PathFileExists(linkPath.c_str()))
return true;
// We have a shortcut, find its target.
COMPtr<IShellLink> shortcut(Create, CLSID_ShellLink);
if (!shortcut)
return false;
COMPtr<IPersistFile> persistFile(Query, shortcut);
if (!shortcut)
return false;
if (FAILED(persistFile->Load(linkPath.c_str(), STGM_READ)))
return false;
if (FAILED(shortcut->Resolve(0, 0)))
return false;
WCHAR targetPath[MAX_PATH];
DWORD targetPathLen = _countof(targetPath);
if (FAILED(shortcut->GetPath(targetPath, targetPathLen, 0, 0)))
return false;
if (!PathFileExists(targetPath))
return false;
// Use the target path as the result path instead.
path = wstring(targetPath);
return true;
}
static wstring cfStringRefToWString(CFStringRef cfStr)
{
Vector<wchar_t> v(CFStringGetLength(cfStr));
CFStringGetCharacters(cfStr, CFRangeMake(0, CFStringGetLength(cfStr)), (UniChar *)v.data());
return wstring(v.data(), v.size());
}
int wmain(int argc, WCHAR* argv[])
{
if (argc != 2 && argc != 3)
{
printf("exe file [mode]\n");
getchar();
return 0;
}
if (argc == 3)
{
JPMode = FALSE;
}
if (wcsstr(argv[1], L".txt") || wcsstr(argv[1], L".exe") || wcsstr(argv[1], L".bat"))
{
//·ÀÖ¹ÍæÎÚÁú233
return 0;
}
WinFile File;
if (FAILED(File.Open(argv[1], WinFile::FileRead)))
{
return 0;
}
PBYTE Buffer = (PBYTE)HeapAlloc(GetProcessHeap(), 0, File.GetSize32());
File.Read(Buffer, File.GetSize32());
HRESULT Result = DisasmProc((wstring(argv[1]) + POST_NAME), Buffer, File.GetSize32());
HeapFree(GetProcessHeap(), 0, Buffer);
File.Release();
return 0;
}
wstring GetUsername()
{
char buf[256] = {0};
getlogin_r(buf, 255);
return wstring(buf, buf+strlen(buf));
}
static wstring widen( const char* str )
{
if (*str == 0)
return wstring();
int chars_in = static_cast<int>(strlen(str));
int chars_out = MultiByteToWideChar(
CP_UTF8, // convert from UTF-8
MB_ERR_INVALID_CHARS, // be strict
str, chars_in,
NULL, 0 // request required buffer size
);
if (chars_out == 0)
throw_nowide_error();
wstring out;
out.resize(chars_out);
int result = MultiByteToWideChar(
CP_UTF8, // convert from UTF-8
MB_ERR_INVALID_CHARS, // be strict
str, chars_in,
&out[0], chars_out
);
if (result == 0)
throw_nowide_error();
return out;
}
void WriteToFile(vector<BYTE> *pdata, wstring & rootname)
{
DWORD numbytes;
GetLocalTime(&timeinfo);
wstring extension = L".spaceball";
swprintf_s(holdertime, L"%02d%02d%02d%ls", timeinfo.wHour, timeinfo.wMinute, timeinfo.wSecond,extension.c_str());
wstring filename = rootname + wstring(holdertime);
HANDLE fileholder;
LPCWSTR stuff= (wchar_t*)filename.c_str();
fileholder = CreateFile(stuff, GENERIC_WRITE , FILE_SHARE_READ, NULL,CREATE_NEW, 0,NULL);
int datasize = (int)pdata->size();
//int datasize = (int)pdata->size()- 8; I assume subtracting 8 was to trim off delimiters. Dunno!
vector<BYTE>::iterator it = pdata ->begin();
char * buffer = (char *)calloc(datasize,sizeof(BYTE));
for( int i = 0; i < datasize; ++i)
{
buffer[i]=*it;
pdata->erase(it);
}
if(!WriteFile(fileholder, buffer,(DWORD)datasize,&numbytes,NULL))
printf("Error Writing to file?");
else
printf("Wrote to file just fine.");
free(buffer);
CloseHandle(fileholder);
}
static inline wstring ToAppropriateStr(string str, wchar_t typeOfCharInReturnString)
{
const size_t MAX_OPTIONS_LENGTH = 8192;
wchar_t wideString[MAX_OPTIONS_LENGTH] = {0};
_snwprintf_s(wideString, MAX_OPTIONS_LENGTH, _TRUNCATE, L"%hs", str.c_str());
return wstring(wideString);
}
const bool Registry::Read(const wstring keyName, wstring *out, const wstring defaultValue) const
{
// Default the return value immediately
*out = defaultValue;
if (!good) return false;
// Read the value once to get the size of the string
long result = 0;
DWORD size = 0;
result = RegQueryValueEx(key, keyName.c_str(), 0, NULL, NULL, &size);
// Read the value again to get the actual string
if (result == ERROR_SUCCESS)
{
wchar_t *data = new wchar_t[size + 1];
if (!data) return false;
result = RegQueryValueEx(key, keyName.c_str(), 0, NULL, (LPBYTE)data, &size);
if (result == ERROR_SUCCESS) *out = wstring(data);
if (data) delete[] data;
data = 0;
}
// 'out' would have only been set on success, otherwise the
// default still exists in 'out', so we're all set
return (result == ERROR_SUCCESS);
}
HRESULT ComReg::UnRegisterCoclass(const GUID& clsid)
{
enum { clsid_strlen = 39 };
wchar_t clsid_str[clsid_strlen];
const int n = StringFromGUID2(clsid, clsid_str, clsid_strlen);
assert(n == clsid_strlen);
n;
const wstring clsid_keyname = wstring(L"CLSID\\") + clsid_str;
Registry::Key clsid_key(HKEY_CLASSES_ROOT, clsid_keyname);
//TODO: KEY_QUERY_VALUE | KEY_SET_VALUE);
if (!clsid_key.is_open())
return S_OK;
Registry::Key subkey(clsid_key, L"VersionIndependentProgID"); //open
if (subkey.is_open())
{
wstring val;
if (subkey(val))
{
const DWORD dw = Registry::SHDeleteKey(HKEY_CLASSES_ROOT, val);
assert((dw == ERROR_SUCCESS) || (dw == ERROR_FILE_NOT_FOUND));
dw;
//TODO: delete subkey from clsid_key
}
}
subkey.open(clsid_key, L"ProgID");
if (subkey.is_open())
{
wstring val;
if (subkey(val))
{
const DWORD dw = Registry::SHDeleteKey(HKEY_CLASSES_ROOT, val);
assert((dw == ERROR_SUCCESS) || (dw == ERROR_FILE_NOT_FOUND));
dw;
//TODO: delete subkey
}
}
subkey.close();
clsid_key.close();
const DWORD dw = Registry::SHDeleteKey(HKEY_CLASSES_ROOT, clsid_keyname);
assert((dw == ERROR_SUCCESS) || (dw == ERROR_FILE_NOT_FOUND));
dw;
return S_OK;
}
void OriginalMethodPreparation::FillIndirectionPreparation(MetadataDispenser const *pDisp, MethodGenerator *pTarget, PrigData &prigData)
{
using boost::timer::cpu_timer;
using boost::timer::default_places;
using std::wstring;
using std::vector;
auto timer = cpu_timer();
_ASSERTE(prigData.m_pMSCorLibDll);
auto const *pMSCorLibDll = prigData.m_pMSCorLibDll;
auto const *pInt32 = pMSCorLibDll->GetType(L"System.Int32");
auto const *pBoolean = pMSCorLibDll->GetType(L"System.Boolean");
CPPANONYM_V_LOG1("Processing time to get BCL definitions: %|1$s|.", timer.format(default_places, "%ws wall, %us user + %ss system = %ts CPU (%p%)"));
timer = cpu_timer();
auto const *pTryPrigTarget = static_cast<IMethod *>(nullptr);
{
auto *pDeclaringTypeGen = pTarget->GetDeclaringTypeGenerator();
auto name = wstring(L"TryPrig") + pTarget->GetName();
auto attr = MethodAttributes::MA_PRIVATE | MethodAttributes::MA_HIDE_BY_SIG | MethodAttributes::MA_STATIC;
auto callingConvention = CallingConventions::CC_STANDARD;
auto const *pRetType = pBoolean;
auto paramTypes = vector<IType const *>();
{
if (pTarget->GetReturnType()->GetKind() != TypeKinds::TK_VOID)
paramTypes.push_back(pTarget->GetReturnType()->MakeByRefType());
if (!pTarget->IsStatic())
{
auto const *pDeclaringType = pTarget->GetDeclaringType();
auto isGenericType = pDeclaringType->IsGenericType();
auto isValueType = pDeclaringType->IsValueType();
if (isGenericType)
pDeclaringType = MakeGenericExplicitItsInstance(pDeclaringType);
if (isValueType)
pDeclaringType = pDeclaringType->MakeByRefType();
paramTypes.push_back(pDeclaringType);
}
auto const ¶ms = pTarget->GetParameters();
BOOST_FOREACH (auto const &pParam, params)
{
auto const *pParamType = pParam->GetParameterType();
paramTypes.push_back(pParamType);
}
}
auto *pTryPrigTargetGen = pDeclaringTypeGen->DefineMethod(name, attr, callingConvention, pRetType, paramTypes);
if (pTarget->IsGenericMethod())
{
auto names = vector<wstring>();
auto const &genericArgs = pTarget->GetGenericArguments();
BOOST_FOREACH (auto const &pGenericArg, genericArgs)
names.push_back(pGenericArg->GetFullName());
pTryPrigTargetGen->DefineGenericParameters(names);
}
static bool resolveCygwinPath(const wstring& cygwinPath, wstring& windowsPath)
{
wstring fileProtocol = L"file://";
bool isFileProtocol = cygwinPath.find(fileProtocol) != string::npos;
if (cygwinPath[isFileProtocol ? 7 : 0] != '/') // ensure path is absolute
return false;
// Get the Root path.
WCHAR rootPath[MAX_PATH];
DWORD rootPathSize = _countof(rootPath);
DWORD keyType;
DWORD result = ::SHGetValueW(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\Cygnus Solutions\\Cygwin\\mounts v2\\/"), TEXT("native"), &keyType, &rootPath, &rootPathSize);
if (result != ERROR_SUCCESS || keyType != REG_SZ) {
// Cygwin 1.7 doesn't store Cygwin's root as a mount point anymore, because mount points are now stored in /etc/fstab.
// However, /etc/fstab doesn't contain any information about where / is located as a Windows path, so we need to use Cygwin's
// new registry key that has the root.
result = ::SHGetValueW(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\Cygwin\\setup"), TEXT("rootdir"), &keyType, &rootPath, &rootPathSize);
if (result != ERROR_SUCCESS || keyType != REG_SZ)
return false;
}
windowsPath = wstring(rootPath, rootPathSize);
int oldPos = isFileProtocol ? 8 : 1;
while (1) {
int newPos = cygwinPath.find('/', oldPos);
if (newPos == -1) {
wstring pathComponent = cygwinPath.substr(oldPos);
if (!appendComponentToPath(windowsPath, pathComponent))
return false;
if (!followShortcuts(windowsPath))
return false;
break;
}
wstring pathComponent = cygwinPath.substr(oldPos, newPos - oldPos);
if (!appendComponentToPath(windowsPath, pathComponent))
return false;
if (!followShortcuts(windowsPath))
return false;
oldPos = newPos + 1;
}
if (isFileProtocol)
windowsPath = fileProtocol + windowsPath;
return true;
}
wstring ChunkFormattingBrackets :: FormatWord(const wstring& token, const wstring& label)
{
wstring bio = label;
wstring prev = prevBIO;
prevBIO = bio;
wstring res0;
if(label == L"BH" || label == L"IH")
{
res0 = token;
res0.append(L"[X]");
}
else
{
res0 = token;
}
if(bio == L"I" || bio == L"IH")
{
return res0;
}
if(bio == L"B" || bio == L"BH")
{
if(prev != L"O")
{
return wstring(L"] [").append(res0);
}
else
{
return wstring(L"[").append(res0);
}
}
if(prev != L"O")
{
return wstring(L"] ").append(res0);
}
return res0;
}
wstring MultiBaseSymbol::to_string() const noexcept {
auto representation = wstring();
representation.reserve(20);
for (const auto &symbol : _bases) {
representation.append(symbol.to_string());
}
return representation;
}
wstring to_wstring(const char* s)
{
auto len = strlen(s); // length without null terminator
auto wlen = MultiByteToWideChar(CP_ACP, 0, s, len, nullptr, 0);
if (len == -1)
return wstring();
wstring str(wlen, L'\0');
MultiByteToWideChar(CP_ACP, 0, s, len, &str.front(), wlen);
return str;
}
wstring NBTools::GetApplicationPath()
{
std::vector<WCHAR> curDir(MAX_PATH);
DWORD result = GetModuleFileName(NULL, &curDir[0], MAX_PATH);
while(result == curDir.size()) {
curDir.resize(curDir.size() * 2);
result = GetModuleFileName(NULL, &curDir[0], (DWORD)curDir.size());
}
return wstring(curDir.begin(), curDir.begin() + result);
return L"";
}
wstring StrToWstr(const string& str, UINT code_page) {
if (!str.empty()) {
int length = MultiByteToWideChar(code_page, 0, str.c_str(), -1, nullptr, 0);
if (length > 0) {
vector<wchar_t> output(length);
MultiByteToWideChar(code_page, 0, str.c_str(), -1, &output[0], length);
return &output[0];
}
}
return wstring();
}
BOOL MainDialog::OnInitDialog()
{
CDialogEx::OnInitDialog();
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(icon_, TRUE); // Set big icon
SetIcon(icon_, FALSE); // Set small icon
const wchar_t* defaultDir = L"c:/";
wstring d = Preference::GetInstance()->GetAudioDir();
audioDir_.SetWindowText(d.empty() ? defaultDir : d.c_str());
if (d.empty())
Preference::GetInstance()->SetAudioDir(wstring(defaultDir));
d = Preference::GetInstance()->GetResultDir();
resultDir_.SetWindowText(d.empty() ? defaultDir : d.c_str());
if (d.empty())
Preference::GetInstance()->SetResultDir(wstring(defaultDir));
return TRUE; // return TRUE unless you set the focus to a control
}
static wstring descriptionSuitableForTestResult(IWebURLResponse* response)
{
if (!response)
return L"(null)";
BSTR urlBSTR;
if (FAILED(response->URL(&urlBSTR)))
return wstring();
wstring url = urlSuitableForTestResult(wstringFromBSTR(urlBSTR));
::SysFreeString(urlBSTR);
return L"<NSURLResponse " + url + L">";
}
Tokenizer::Tokenizer()
: character_(initialize_character_set())
, delimiter_(initialize_delimiters(L".,;:?+#=@|_`-*/^$%~&!\\'\"()<>[]{}\0\r\n\t\b\a\v\f\r"))
{
auto start = high_resolution_clock::now();
char const * filename_[] = {
"vietnamese.txt" ,
"vietnamese-stopwords.txt"
};
TokenContainer * data_[2] = {
&vocabulary , &stopword_
};
auto not_character = character_.end();
for (int i = 0; i < 2; ++i)
{
boost::iostreams::mapped_file reader(filename_[i] , mapped_file::readonly);
if (!reader.is_open())
// Cannot read vocabulary, cannot proceed on
throw "Cannot open " + string(filename_[i]) + " to read vocabulary.\n";
wchar const * it , *endit;
it = 1 + reinterpret_cast<wchar const *>(reader.const_begin());
endit = reinterpret_cast<wchar const *>(reader.const_end());
while (it != endit)
{
Token token;
while (true)
{
auto begin = it;
while (character_.find(*it) != not_character)
++it;
token.push_back(wstring(begin , it - begin));
if ((*it) == L'\n' || (*it) == L'\0')
break;
++it;
}
data_[i]->insert(token);
++it;
}
reader.close();
}
auto finish = high_resolution_clock::now();
cout << "Reading vocabulary and stop words: " << duration_cast<milliseconds>(finish - start).count() << "ms\n";
}
static bool resolveCygwinPath(const wstring& cygwinPath, wstring& windowsPath)
{
wstring fileProtocol = L"file://";
bool isFileProtocol = cygwinPath.find(fileProtocol) != string::npos;
if (cygwinPath[isFileProtocol ? 7 : 0] != '/') // ensure path is absolute
return false;
// Get the Root path.
WCHAR rootPath[MAX_PATH];
DWORD rootPathSize = _countof(rootPath);
DWORD keyType;
DWORD result = ::SHGetValueW(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\Cygnus Solutions\\Cygwin\\mounts v2\\/"), TEXT("native"), &keyType, &rootPath, &rootPathSize);
if (result != ERROR_SUCCESS || keyType != REG_SZ)
return false;
windowsPath = wstring(rootPath, rootPathSize);
int oldPos = isFileProtocol ? 8 : 1;
while (1) {
int newPos = cygwinPath.find('/', oldPos);
if (newPos == -1) {
wstring pathComponent = cygwinPath.substr(oldPos);
if (!appendComponentToPath(windowsPath, pathComponent))
return false;
if (!followShortcuts(windowsPath))
return false;
break;
}
wstring pathComponent = cygwinPath.substr(oldPos, newPos - oldPos);
if (!appendComponentToPath(windowsPath, pathComponent))
return false;
if (!followShortcuts(windowsPath))
return false;
oldPos = newPos + 1;
}
if (isFileProtocol)
windowsPath = fileProtocol + windowsPath;
return true;
}
wstring ConvertCodepageToWString( std::string s, int iCodePage )
{
if( s.empty() )
return wstring();
int iBytes = MultiByteToWideChar( iCodePage, 0, s.data(), s.size(), nullptr, 0 );
ASSERT_M( iBytes > 0, werr_format( GetLastError(), "MultiByteToWideChar" ).c_str() );
wchar_t *pTemp = new wchar_t[iBytes];
MultiByteToWideChar( iCodePage, 0, s.data(), s.size(), pTemp, iBytes );
wstring sRet( pTemp, iBytes );
delete [] pTemp;
return sRet;
}
wstring string_to_wstring(const string& src,bool utf8)
{
if(src.empty())
return wstring();
UINT cp=utf8?CP_UTF8:CP_ACP;
int size=MultiByteToWideChar(cp,0,src.c_str(),-1,NULL,0);
if(size==0)
throw runtime_error("Unable to convert a string");
wstring s(size,'\0');
wchar_t *buff=new wchar_t[size];
MultiByteToWideChar(cp,0,src.c_str(),-1,buff,size);
s.assign(buff);
delete[] buff;
return s;
}
int check_network(vector <nInterface>& vInterfaces)
{
const wchar_t *perfIn = L"\\Network Interface(*)\\Bytes Received/sec";
const wchar_t *perfOut = L"\\Network Interface(*)\\Bytes Sent/sec";
PDH_HQUERY phQuery = NULL;
PDH_HCOUNTER phCounterIn, phCounterOut;
DWORD dwBufferSizeIn = 0, dwBufferSizeOut = 0, dwItemCount = 0;
PDH_FMT_COUNTERVALUE_ITEM *pDisplayValuesIn = NULL, *pDisplayValuesOut = NULL;
if (PdhOpenQuery(NULL, NULL, &phQuery) != ERROR_SUCCESS)
goto die;
//Totaly reasonable statement
if (PdhOpenQuery(NULL, NULL, &phQuery) == ERROR_SUCCESS) {
if (PdhAddEnglishCounter(phQuery, perfIn, NULL, &phCounterIn) == ERROR_SUCCESS) {
if (PdhAddEnglishCounter(phQuery, perfOut, NULL, &phCounterOut) == ERROR_SUCCESS) {
if (PdhCollectQueryData(phQuery) == ERROR_SUCCESS) {
Sleep(1000);
if (PdhCollectQueryData(phQuery) == ERROR_SUCCESS) {
if (PdhGetFormattedCounterArray(phCounterIn, PDH_FMT_LONG, &dwBufferSizeIn, &dwItemCount, pDisplayValuesIn) == PDH_MORE_DATA &&
PdhGetFormattedCounterArray(phCounterOut, PDH_FMT_LONG, &dwBufferSizeOut, &dwItemCount, pDisplayValuesOut) == PDH_MORE_DATA) {
pDisplayValuesIn = new PDH_FMT_COUNTERVALUE_ITEM[dwItemCount*dwBufferSizeIn];
pDisplayValuesOut = new PDH_FMT_COUNTERVALUE_ITEM[dwItemCount*dwBufferSizeOut];
if (PdhGetFormattedCounterArray(phCounterIn, PDH_FMT_LONG, &dwBufferSizeIn, &dwItemCount, pDisplayValuesIn) == ERROR_SUCCESS &&
PdhGetFormattedCounterArray(phCounterOut, PDH_FMT_LONG, &dwBufferSizeOut, &dwItemCount, pDisplayValuesOut) == ERROR_SUCCESS) {
for (DWORD i = 0; i < dwItemCount; i++) {
nInterface *iface = new nInterface(wstring(pDisplayValuesIn[i].szName));
iface->BytesInSec = pDisplayValuesIn[i].FmtValue.longValue;
iface->BytesOutSec = pDisplayValuesOut[i].FmtValue.longValue;
vInterfaces.push_back(*iface);
}
return -1;
}
}
}
}
}
}
}
die:
die();
if (phQuery)
PdhCloseQuery(phQuery);
return 3;
}
bool appendComponentToPath(wstring& path, const wstring& component)
{
WCHAR buffer[MAX_PATH];
if (path.size() + 1 > MAX_PATH)
return false;
memcpy(buffer, path.data(), path.size() * sizeof(WCHAR));
buffer[path.size()] = '\0';
if (!PathAppendW(buffer, component.c_str()))
return false;
path = wstring(buffer);
return true;
}
