void _DBGPRINT( LPCWSTR kwszFunction, INT iLineNumber, LPCWSTR kwszDebugFormatString, ... )
{
INT cbFormatString = 0;
va_list args;
PWCHAR wszDebugString = NULL;
size_t st_Offset = 0;
va_start( args, kwszDebugFormatString );
cbFormatString = _scwprintf( L"[%s:%d] ", kwszFunction, iLineNumber ) * sizeof( WCHAR );
cbFormatString += _vscwprintf( kwszDebugFormatString, args ) * sizeof( WCHAR ) + 2;
/* Depending on the size of the format string, allocate space on the stack or the heap. */
wszDebugString = (PWCHAR)_malloca( cbFormatString );
/* Populate the buffer with the contents of the format string. */
StringCbPrintfW( wszDebugString, cbFormatString, L"[%s:%d] ", kwszFunction, iLineNumber );
StringCbLengthW( wszDebugString, cbFormatString, &st_Offset );
StringCbVPrintfW( &wszDebugString[st_Offset / sizeof(WCHAR)], cbFormatString - st_Offset, kwszDebugFormatString, args );
OutputDebugStringW( wszDebugString );
_freea( wszDebugString );
va_end( args );
}
HRESULT CRefClient::AddObjects()
///////////////////////////////////////////////////////////////////
//
// AddObject will add a set of objects to the refresher. The
// method will update m_aInstances with the instance data.
//
// Returns a status code. Use the SUCCEEDED() and FAILED() macros
// to interpret results.
//
///////////////////////////////////////////////////////////////////
//ok
{
HRESULT hRes = WBEM_NO_ERROR;
long lIndex = 0;
WCHAR wcsObjName[MAX_PATH + 50];
// Loop through all instances of Win32_BasicHiPerf and add them to the refresher
// =============================================================================
for ( lIndex = 0; lIndex < clNumInstances; lIndex++ )
{
IWbemClassObject* pObj = NULL;
IWbemObjectAccess* pAccess = NULL;
long lID;
// Set the object path (e.g. Win32_BasicHiPerf=1)
// ==============================================
StringCbPrintfW(wcsObjName, sizeof(wcsObjName), L"%s=%i", cwcsObjectPath, lIndex );
// Add the object
// ==============
hRes = m_pConfig->AddObjectByPath( m_pNameSpace, wcsObjName, 0, NULL, &pObj, &lID );
if ( FAILED( hRes ) )
{
printf( "AddObjectByPath() failed, 0x%x\n", hRes );
return hRes;
}
// Save the IWbemObjectAccess interface
// ====================================
hRes = pObj->QueryInterface( IID_IWbemObjectAccess, (void**) &pAccess );
pObj->Release();
m_Instances[lIndex].Set(pAccess, lID);
// Set does it's own AddRef()
// ==========================
pAccess->Release();
}
return hRes;
}
INT_PTR
CALLBACK
ProcessorDlgProc (HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
switch (uMessage) {
case WM_INITDIALOG:
{
WCHAR szFeatures[MAX_PATH] = L"";
WCHAR szModel[3];
WCHAR szStepping[3];
WCHAR szCurrentMhz[10];
BOOL bFirst = TRUE;
SYSTEM_INFO SystemInfo;
PROCESSOR_POWER_INFORMATION PowerInfo;
if (IsProcessorFeaturePresent(PF_MMX_INSTRUCTIONS_AVAILABLE))
AddFeature(szFeatures, sizeof(szFeatures), L"MMX", &bFirst);
if (IsProcessorFeaturePresent(PF_XMMI_INSTRUCTIONS_AVAILABLE))
AddFeature(szFeatures, sizeof(szFeatures), L"SSE", &bFirst);
if (IsProcessorFeaturePresent(PF_XMMI64_INSTRUCTIONS_AVAILABLE))
AddFeature(szFeatures, sizeof(szFeatures), L"SSE2", &bFirst);
/*if (IsProcessorFeaturePresent(PF_SSE3_INSTRUCTIONS_AVAILABLE))
AddFeature(szFeatures, sizeof(szFeatures), L"SSE3", &bFirst); */
if (IsProcessorFeaturePresent(PF_3DNOW_INSTRUCTIONS_AVAILABLE))
AddFeature(szFeatures, sizeof(szFeatures), L"3DNOW", &bFirst);
SetDlgItemTextW(hDlg, IDC_FEATURES, szFeatures);
GetSystemInfo(&SystemInfo);
StringCbPrintfW(szModel, sizeof(szModel), L"%x", HIBYTE(SystemInfo.wProcessorRevision));
StringCbPrintfW(szStepping, sizeof(szStepping), L"%d", LOBYTE(SystemInfo.wProcessorRevision));
SetDlgItemTextW(hDlg, IDC_MODEL, szModel);
SetDlgItemTextW(hDlg, IDC_STEPPING, szStepping);
CallNtPowerInformation(11, NULL, 0, &PowerInfo, sizeof(PowerInfo));
StringCbPrintfW(szCurrentMhz, sizeof(szCurrentMhz), L"%ld %s", PowerInfo.CurrentMhz, L"MHz");
SetDlgItemTextW(hDlg, IDC_CORESPEED, szCurrentMhz);
return TRUE;
}
}
return FALSE;
}
void get_full_path(wchar_t *file_name, wchar_t *file_name2)
{
// current directory 를 구한다.
wchar_t *buf = NULL;
uint32_t buflen = 0;
buflen = GetCurrentDirectoryW(buflen, buf);
if (0 == buflen)
{
fprintf(stderr, "err, GetCurrentDirectoryW() failed. gle = 0x%08x", GetLastError());
return;
}
buf = (PWSTR)malloc(sizeof(WCHAR)* buflen);
if (0 == GetCurrentDirectoryW(buflen, buf))
{
fprintf(stderr, "err, GetCurrentDirectoryW() failed. gle = 0x%08x", GetLastError());
free(buf);
return;
}
// current dir \\ bob.txt, bob2.txt 파일명 생성
if (!SUCCEEDED(StringCbPrintfW(
file_name,
sizeof(wchar_t) * FILE_NAME_SIZE,
L"%ws\\bob.txt",
buf)))
{
fprintf(stderr, "err, can not create file name");
free(buf);
return;
}
if (!SUCCEEDED(StringCbPrintfW(
file_name2,
sizeof(wchar_t) * FILE_NAME_SIZE,
L"%ws\\bob2.txt",
buf)))
{
fprintf(stderr, "err, can not create file name");
free(buf);
return;
}
free(buf); buf = NULL;
}
bool copy_bob()
{
wchar_t *buf = NULL;
uint32_t buflen = 0;
buflen = GetCurrentDirectoryW(buflen, buf);
if (buflen == 0)
{
print("err GetCurrentDirectoryW() failed gle = 0x%08x", GetLastError());
return false;
}
buf = (PWSTR)malloc(sizeof(WCHAR)*buflen);
if (GetCurrentDirectoryW(buflen, buf) == 0)
{
print("err GetCurrentDirectoryW() failed gle = 0x%08x", GetLastError());
free(buf);
return false;
}
wchar_t file_name[260];
if (!SUCCEEDED(StringCbPrintfW(file_name, sizeof(file_name), L"%ws\\bob.txt", buf)))
{
printf("err can not create name %08x", GetLastError());
return false;
}
wchar_t file_copy[260];
if (!SUCCEEDED(StringCbPrintfW(file_copy, sizeof(file_copy), L"%ws\\bob2.txt", buf)))
{
printf("err can not create name %08x", GetLastError());
return false;
}
free(buf);
buf = NULL;
//파일 복사
CopyFile(file_name, file_copy, 0);
return TRUE;
}
LPWSTR GetINIFullPath(LPCWSTR lpFileName)
{
WCHAR szDir[MAX_PATH];
static WCHAR szBuffer[MAX_PATH];
GetStorageDirectory(szDir, _countof(szDir));
StringCbPrintfW(szBuffer, sizeof(szBuffer), L"%ls\\rapps\\%ls", szDir, lpFileName);
return szBuffer;
}
static int MakeService(SC_HANDLE hScm, const wchar_t *serviceName, SC_HANDLE *hService, DWORD *tag)
{
DWORD ret;
HKEY hKey = NULL;
DWORD type = 0, tagData = 0, tagSize;
wchar_t keyName[256];
SetLastError(DNS_ERROR_RCODE_NXRRSET);
*hService = CreateServiceW(
hScm,
serviceName,
NULL,
DELETE,
SERVICE_KERNEL_DRIVER,
SERVICE_BOOT_START,
SERVICE_ERROR_IGNORE,
L"%systemroot%\\drivers\\win32k.sys",
L"advapi32_apitest_CreateService_Test_Group",
tag,
NULL,
NULL,
NULL);
ok(*hService != NULL, "Failed to create service, error=0x%08lx\n", GetLastError());
if (!*hService)
{
skip("No service; cannot proceed with CreateService test\n");
return 1;
}
ok_err(ERROR_SUCCESS);
ok(*tag != 0, "tag is zero, expected nonzero\n");
StringCbPrintfW(keyName, sizeof keyName, L"System\\CurrentControlSet\\Services\\%ls", serviceName);
ret = RegOpenKeyW(HKEY_LOCAL_MACHINE, keyName, &hKey);
ok(ret == ERROR_SUCCESS, "RegOpenKeyW failed with 0x%08lx\n", ret);
if (ret)
{
skip("No regkey; cannot proceed with CreateService test\n");
return 2;
}
tagSize = sizeof tagData;
ret = RegQueryValueExW(hKey, L"Tag", NULL, &type, (PBYTE)&tagData, &tagSize);
ok(ret == ERROR_SUCCESS, "RegQueryValueExW returned 0x%08lx\n", ret);
ok(type == REG_DWORD, "type=%lu, expected REG_DWORD\n", type);
ok(tagSize == sizeof tagData, "tagSize=%lu, expected 4\n", tagSize);
ok(tagData == *tag, "tag=%lu, but registry says %lu\n", *tag, tagData);
RegCloseKey(hKey);
return 0;
}
static void file_rmdir_test(void)
{
BOOL Success;
WCHAR FileName[MAX_PATH];
for (ULONG Index = 0; OptFileCount > Index; Index++)
{
StringCbPrintfW(FileName, sizeof FileName, L"fsbench-dir%lu", Index);
Success = RemoveDirectoryW(FileName);
ASSERT(Success);
}
}
static void file_delete_test(void)
{
BOOL Success;
WCHAR FileName[MAX_PATH];
for (ULONG Index = 0; OptFileCount > Index; Index++)
{
StringCbPrintfW(FileName, sizeof FileName, L"fsbench-file%lu", Index);
Success = DeleteFileW(FileName);
ASSERT(Success);
}
}
static void mmap_dotest(ULONG CreateDisposition, ULONG CreateFlags,
ULONG FileSize, ULONG BufferSize, ULONG Count)
{
WCHAR FileName[MAX_PATH];
HANDLE Handle, Mapping;
BOOL Success;
PUINT8 MappedView;
StringCbPrintfW(FileName, sizeof FileName, L"fsbench-file");
Handle = CreateFileW(FileName,
GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
0,
CreateDisposition,
FILE_ATTRIBUTE_NORMAL | CreateFlags,
0);
ASSERT(INVALID_HANDLE_VALUE != Handle);
Mapping = CreateFileMappingW(Handle, 0, PAGE_READWRITE,
0, FileSize, 0);
ASSERT(0 != Mapping);
MappedView = MapViewOfFile(Mapping, FILE_MAP_ALL_ACCESS, 0, 0, 0);
ASSERT(0 != MappedView);
for (ULONG Index = 0; Count > Index; Index++)
{
for (ULONG I = 0, N = FileSize / BufferSize; N > I; I++)
{
if (CREATE_NEW == CreateDisposition)
{
for (ULONG J = 0; BufferSize > J; J++)
MappedView[I * BufferSize + J] = 0;
}
else
{
ULONG Total = 0;
for (ULONG J = 0; BufferSize > J; J++)
Total += MappedView[I * BufferSize + J];
ASSERT(0 == Total);
}
}
}
Success = UnmapViewOfFile(MappedView);
ASSERT(Success);
Success = CloseHandle(Mapping);
ASSERT(Success);
Success = CloseHandle(Handle);
ASSERT(Success);
}
static void file_attr_test(void)
{
WCHAR FileName[MAX_PATH];
DWORD FileAttributes;
for (ULONG ListIndex = 0; OptListCount > ListIndex; ListIndex++)
for (ULONG Index = 0; OptFileCount > Index; Index++)
{
StringCbPrintfW(FileName, sizeof FileName, L"fsbench-file%lu", Index);
FileAttributes = GetFileAttributesW(FileName);
ASSERT(INVALID_FILE_ATTRIBUTES != FileAttributes);
}
}
static void exec_rename_dotest(ULONG Flags, PWSTR Prefix, ULONG FileInfoTimeout)
{
void *memfs = memfs_start_ex(Flags, FileInfoTimeout);
WCHAR FilePath[MAX_PATH], File2Path[MAX_PATH], File3Path[MAX_PATH];
HANDLE Process;
HANDLE Handle;
StringCbPrintfW(FilePath, sizeof FilePath, L"%s%s\\helper.exe",
Prefix ? L"" : L"\\\\?\\GLOBALROOT", Prefix ? Prefix : memfs_volumename(memfs));
StringCbPrintfW(File2Path, sizeof File2Path, L"%s%s\\helper2.exe",
Prefix ? L"" : L"\\\\?\\GLOBALROOT", Prefix ? Prefix : memfs_volumename(memfs));
StringCbPrintfW(File3Path, sizeof File3Path, L"%s%s\\helper3.exe",
Prefix ? L"" : L"\\\\?\\GLOBALROOT", Prefix ? Prefix : memfs_volumename(memfs));
Handle = CreateFileW(File3Path,
FILE_WRITE_DATA, FILE_SHARE_WRITE, 0,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
ASSERT(INVALID_HANDLE_VALUE != Handle);
CloseHandle(Handle);
ExecHelper(FilePath, 1000, &Process);
ASSERT(MoveFileExW(FilePath, File2Path, MOVEFILE_REPLACE_EXISTING));
ASSERT(MoveFileExW(File2Path, FilePath, MOVEFILE_REPLACE_EXISTING));
ASSERT(!MoveFileExW(File3Path, FilePath, MOVEFILE_REPLACE_EXISTING));
ASSERT(ERROR_ACCESS_DENIED == GetLastError());
WaitHelper(Process, 1000);
ASSERT(MoveFileExW(File3Path, FilePath, MOVEFILE_REPLACE_EXISTING));
ASSERT(DeleteFileW(FilePath));
memfs_stop(memfs);
}
static NTSTATUS CreateHelperProcess(PWSTR FileName, ULONG Timeout, PHANDLE PProcess)
{
HANDLE Event;
SECURITY_ATTRIBUTES EventAttributes;
WCHAR CommandLine[MAX_PATH + 64];
STARTUPINFOW StartupInfo;
PROCESS_INFORMATION ProcessInfo;
DWORD WaitResult;
NTSTATUS Result;
memset(&EventAttributes, 0, sizeof EventAttributes);
EventAttributes.nLength = sizeof EventAttributes;
EventAttributes.bInheritHandle = TRUE;
Event = CreateEventW(&EventAttributes, TRUE, FALSE, 0);
if (0 == Event)
return FspNtStatusFromWin32(GetLastError());
StringCbPrintfW(CommandLine, sizeof CommandLine, L"\"%s\" %lx %lx",
FileName, (ULONG)(UINT_PTR)Event, Timeout);
memset(&StartupInfo, 0, sizeof StartupInfo);
StartupInfo.cb = sizeof StartupInfo;
// !!!: need hook
if (!CreateProcessW(FileName, CommandLine, 0, 0, TRUE, 0, 0, 0, &StartupInfo, &ProcessInfo))
{
Result = FspNtStatusFromWin32(GetLastError());
CloseHandle(Event);
return Result;
}
WaitResult = WaitForSingleObject(Event, 3000);
if (WaitResult == WAIT_FAILED)
Result = FspNtStatusFromWin32(GetLastError());
else if (WaitResult == WAIT_TIMEOUT)
Result = STATUS_UNSUCCESSFUL;
else
Result = STATUS_SUCCESS;
CloseHandle(Event);
CloseHandle(ProcessInfo.hThread);
if (!NT_SUCCESS(Result))
CloseHandle(ProcessInfo.hProcess);
else
*PProcess = ProcessInfo.hProcess;
return Result;
}
BOOL
CFileDefExt::InitFileType(HWND hwndDlg)
{
TRACE("path %s\n", debugstr_w(m_wszPath));
HWND hDlgCtrl = GetDlgItem(hwndDlg, 14005);
if (hDlgCtrl == NULL)
return FALSE;
/* Get file information */
SHFILEINFO fi;
if (!SHGetFileInfoW(m_wszPath, 0, &fi, sizeof(fi), SHGFI_TYPENAME|SHGFI_ICON))
{
ERR("SHGetFileInfoW failed for %ls (%lu)\n", m_wszPath, GetLastError());
fi.szTypeName[0] = L'\0';
fi.hIcon = NULL;
}
LPCWSTR pwszExt = PathFindExtensionW(m_wszPath);
if (pwszExt[0])
{
WCHAR wszBuf[256];
if (!fi.szTypeName[0])
{
/* The file type is unknown, so default to string "FileExtension File" */
size_t cchRemaining = 0;
LPWSTR pwszEnd = NULL;
StringCchPrintfExW(wszBuf, _countof(wszBuf), &pwszEnd, &cchRemaining, 0, L"%s ", pwszExt + 1);
SendMessageW(hDlgCtrl, WM_GETTEXT, (WPARAM)cchRemaining, (LPARAM)pwszEnd);
SendMessageW(hDlgCtrl, WM_SETTEXT, (WPARAM)NULL, (LPARAM)wszBuf);
}
else
{
/* Update file type */
StringCbPrintfW(wszBuf, sizeof(wszBuf), L"%s (%s)", fi.szTypeName, pwszExt);
SendMessageW(hDlgCtrl, WM_SETTEXT, (WPARAM)NULL, (LPARAM)wszBuf);
}
}
/* Update file icon */
if (fi.hIcon)
SendDlgItemMessageW(hwndDlg, 14000, STM_SETICON, (WPARAM)fi.hIcon, 0);
else
ERR("No icon %ls\n", m_wszPath);
return TRUE;
}
static void rdwr_dotest(ULONG CreateDisposition, ULONG CreateFlags,
ULONG FileSize, ULONG BufferSize, ULONG Count)
{
WCHAR FileName[MAX_PATH];
HANDLE Handle;
BOOL Success;
PVOID Buffer;
DWORD BytesTransferred;
Buffer = _aligned_malloc(BufferSize, BufferSize);
ASSERT(0 != Buffer);
memset(Buffer, 0, BufferSize);
StringCbPrintfW(FileName, sizeof FileName, L"fsbench-file");
Handle = CreateFileW(FileName,
GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
0,
CreateDisposition,
FILE_ATTRIBUTE_NORMAL | CreateFlags,
0);
ASSERT(INVALID_HANDLE_VALUE != Handle);
if (CREATE_NEW == CreateDisposition)
{
BytesTransferred = SetFilePointer(Handle, FileSize, 0, FILE_BEGIN);
ASSERT(FileSize == BytesTransferred);
SetEndOfFile(Handle);
}
for (ULONG Index = 0; Count > Index; Index++)
{
BytesTransferred = SetFilePointer(Handle, 0, 0, FILE_BEGIN);
ASSERT(0 == BytesTransferred);
for (ULONG I = 0, N = FileSize / BufferSize; N > I; I++)
{
if (CREATE_NEW == CreateDisposition)
Success = WriteFile(Handle, Buffer, BufferSize, &BytesTransferred, 0);
else
Success = ReadFile(Handle, Buffer, BufferSize, &BytesTransferred, 0);
ASSERT(Success);
ASSERT(BufferSize == BytesTransferred);
}
}
Success = CloseHandle(Handle);
ASSERT(Success);
_aligned_free(Buffer);
}
void test_runner(void (*run_test)(PCSTR, PCWSTR, void*), void *param)
{
HANDLE hServerPipe = INVALID_HANDLE_VALUE;
HANDLE hThread;
StringCbPrintfW(service_nameW, sizeof(service_nameW), L"WineTestService%lu", GetTickCount());
WideCharToMultiByte(CP_ACP, 0, service_nameW, -1, service_nameA, _countof(service_nameA), NULL, NULL);
//trace("service_name: %ls\n", service_nameW);
StringCbPrintfW(named_pipe_name, sizeof(named_pipe_name), L"\\\\.\\pipe\\%ls_pipe", service_nameW);
hServerPipe = CreateNamedPipeW(named_pipe_name, PIPE_ACCESS_INBOUND,
PIPE_TYPE_MESSAGE|PIPE_READMODE_MESSAGE|PIPE_WAIT, 10, 2048, 2048, 10000, NULL);
ok(hServerPipe != INVALID_HANDLE_VALUE, "CreateNamedPipe failed: %lu\n", GetLastError());
if (hServerPipe == INVALID_HANDLE_VALUE)
return;
hThread = CreateThread(NULL, 0, pipe_thread, (LPVOID)hServerPipe, 0, NULL);
ok(hThread != NULL, "CreateThread failed: %lu\n", GetLastError());
if (!hThread)
goto Quit;
run_test(service_nameA, service_nameW, param);
ok(WaitForSingleObject(hThread, 10000) == WAIT_OBJECT_0, "Timeout waiting for thread\n");
Quit:
if (hThread)
{
/* Be sure to kill the thread if it did not already terminate */
TerminateThread(hThread, 0);
CloseHandle(hThread);
}
if (hServerPipe != INVALID_HANDLE_VALUE)
CloseHandle(hServerPipe);
}
static void file_list_none_test(void)
{
HANDLE Handle;
WCHAR FileName[MAX_PATH];
WIN32_FIND_DATAW FindData;
for (ULONG ListIndex = 0; OptListCount > ListIndex; ListIndex++)
for (ULONG Index = 0; OptFileCount > Index; Index++)
{
StringCbPrintfW(FileName, sizeof FileName, L"{5F849D7F-73AF-49AC-B7C3-657B36EAD5C4}");
Handle = FindFirstFileW(FileName, &FindData);
ASSERT(INVALID_HANDLE_VALUE == Handle);
ASSERT(ERROR_FILE_NOT_FOUND == GetLastError());
}
}
void Cexcxx_wce_sqlDlg::OnBnClickedButton1()
{
wchar_t msg[512];
sqlite3 *db;
int rc;
rc = sqlite3_open("\\My Documents\\test.db", &db);
if( rc ){
StringCbPrintfW(msg, 512,
_T("Can't open database: %hs\r\n"), sqlite3_errmsg(db));
SetDlgItemText(IDC_TEXT_OUT, msg);
} else
SetDlgItemText(IDC_TEXT_OUT, _T("Opened the database.\r\n"));
sqlite3_close(db);
}
int printer(void *dlg, int argc, char **argv, char**azColName) {
int i, offset;
wchar_t msg[512];
memset(msg, 0, 512);
Cexcxx_wce_sqlDlg *dialog = (Cexcxx_wce_sqlDlg *)dlg;
for (i = 0; i < argc; i++) {
dialog->GetDlgItemText(IDC_TEXT_OUT, msg, 512);
offset = wcslen(msg);
StringCbPrintfW(msg + offset, 512 - offset,
_T("%hs%hs = %hs%hs"), i == 0 ? "" : ", ", azColName[i],
argv[i] ? argv[i] : "NULL", (i + 1 == argc) ? "\r\n" : "");
dialog->SetDlgItemText(IDC_TEXT_OUT, msg);
}
return (0);
}
int GetSpaceString(wchar_t *dest, size_t cbDest, uint64 size, BOOL bDevice)
{
const wchar_t * szFmtBytes = L"%.0lf %s";
const wchar_t * szFmtOther = L"%.2lf %s";
const wchar_t * SuffixStr[] = {L"Byte", L"KB", L"MB", L"GB", L"TB"};
const uint64 Muliplier[] = {1, BYTES_PER_KB, BYTES_PER_MB, BYTES_PER_GB, BYTES_PER_TB};
const int nMaxSuffix = sizeof(Muliplier)/sizeof(uint64) - 1;
int i;
for (i=1; i<=nMaxSuffix && size>Muliplier[i]; i++) ;
--i;
if (bDevice) {
wchar_t szTemp[512];
if (StringCbPrintfW(szTemp, sizeof(szTemp),i?szFmtOther:szFmtBytes, size/(double)Muliplier[i], SuffixStr[i]) < 0 )
return -1;
return StringCbPrintfW(dest, cbDest, L"%I64u sectors (%s)", size/SECTOR_SIZE_MSG , szTemp);
}
return StringCbPrintfW(dest, cbDest,i?szFmtOther:szFmtBytes, size/(double)Muliplier[i], SuffixStr[i]);
}
void SetCurrentVolSize(HWND hwndDlg, uint64 size)
{
const uint64 Muliplier[] = {BYTES_PER_KB, BYTES_PER_MB, BYTES_PER_GB, BYTES_PER_TB};
const int IdRadioBtn[] = {IDC_KB, IDC_MB, IDC_GB, IDC_TB};
const int nMaxSuffix = sizeof(Muliplier)/sizeof(uint64) - 1;
int i;
wchar_t szTemp[256];
for (i=1; i<=nMaxSuffix && size>Muliplier[i]; i++) ;
--i;
SendDlgItemMessage (hwndDlg, IdRadioBtn[i], BM_SETCHECK, BST_CHECKED, 0);
StringCbPrintfW(szTemp,sizeof(szTemp),L"%I64u",size/Muliplier[i]);
SetWindowText (GetDlgItem (hwndDlg, IDC_SIZEBOX), szTemp);
}
int wmain(int argc, WCHAR* argv[])
{
WCHAR CmdLine[CMDLINE_LENGTH];
/* Initialize the Console Standard Streams */
ConInitStdStreams();
/*
* If the user hasn't asked for specific help,
* then print out the list of available commands.
*/
if (argc <= 1)
{
ConResPuts(StdOut, IDS_HELP1);
ConResPuts(StdOut, IDS_HELP2);
return 0;
}
/*
* Bad usage (too much options) or we use the /? switch.
* Display help for the HELP command.
*/
if ((argc > 2) || (wcscmp(argv[1], L"/?") == 0))
{
ConResPuts(StdOut, IDS_USAGE);
return 0;
}
/*
* If the command is not an internal one,
* display an information message and exit.
*/
if (!IsInternalCommand(argv[1]))
{
ConResPrintf(StdOut, IDS_NO_ENTRY, argv[1]);
return 0;
}
/*
* Run "<command> /?" in the current command processor.
*/
StringCbPrintfW(CmdLine, sizeof(CmdLine), L"%ls /?", argv[1]);
_flushall();
return _wsystem(CmdLine);
}
static void exec_dotest(ULONG Flags, PWSTR Prefix, ULONG FileInfoTimeout)
{
void *memfs = memfs_start_ex(Flags, FileInfoTimeout);
WCHAR FilePath[MAX_PATH];
HANDLE Process;
StringCbPrintfW(FilePath, sizeof FilePath, L"%s%s\\helper.exe",
Prefix ? L"" : L"\\\\?\\GLOBALROOT", Prefix ? Prefix : memfs_volumename(memfs));
ExecHelper(FilePath, 0, &Process);
WaitHelper(Process, 0);
ASSERT(DeleteFileW(FilePath));
memfs_stop(memfs);
}
static void file_create_dotest(ULONG CreateDisposition)
{
HANDLE Handle;
BOOL Success;
WCHAR FileName[MAX_PATH];
for (ULONG Index = 0; OptFileCount > Index; Index++)
{
StringCbPrintfW(FileName, sizeof FileName, L"fsbench-file%lu", Index);
Handle = CreateFileW(FileName,
GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
0,
CreateDisposition, FILE_ATTRIBUTE_NORMAL,
0);
ASSERT(INVALID_HANDLE_VALUE != Handle);
Success = CloseHandle(Handle);
ASSERT(Success);
}
}
static void file_list_single_test(void)
{
HANDLE Handle;
BOOL Success;
WCHAR FileName[MAX_PATH];
WIN32_FIND_DATAW FindData;
for (ULONG ListIndex = 0; OptListCount > ListIndex; ListIndex++)
for (ULONG Index = 0; OptFileCount > Index; Index++)
{
StringCbPrintfW(FileName, sizeof FileName, L"fsbench-file%lu", Index);
Handle = FindFirstFileW(FileName, &FindData);
ASSERT(INVALID_HANDLE_VALUE != Handle);
do
{
} while (FindNextFileW(Handle, &FindData));
Success = FindClose(Handle);
ASSERT(Success);
}
}
BOOL
CNetConnectionPropertyUi::GetDeviceInstanceID(
OUT LPOLESTR *DeviceInstanceID)
{
LPOLESTR pStr, pResult;
HKEY hKey;
DWORD dwInstanceID;
WCHAR szKeyName[2*MAX_PATH];
WCHAR szInstanceID[2*MAX_PATH];
if (StringFromCLSID(pProperties->guidId, &pStr) != ERROR_SUCCESS)
{
// failed to convert guid to string
return FALSE;
}
StringCbPrintfW(szKeyName, sizeof(szKeyName), L"SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s\\Connection", pStr);
CoTaskMemFree(pStr);
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szKeyName, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
{
// failed to open key
return FALSE;
}
dwInstanceID = sizeof(szInstanceID);
if (RegGetValueW(hKey, NULL, L"PnpInstanceId", RRF_RT_REG_SZ, NULL, (PVOID)szInstanceID, &dwInstanceID) == ERROR_SUCCESS)
{
szInstanceID[MAX_PATH-1] = L'\0';
pResult = (LPOLESTR)CoTaskMemAlloc((wcslen(szInstanceID) + 1) * sizeof(WCHAR));
if (pResult != 0)
{
wcscpy(pResult, szInstanceID);
*DeviceInstanceID = pResult;
RegCloseKey(hKey);
return TRUE;
}
}
RegCloseKey(hKey);
return FALSE;
}
void service_process(BOOL (*start_service)(PCSTR, PCWSTR), int argc, char** argv)
{
BOOL res;
StringCbCopyA(service_nameA, sizeof(service_nameA), argv[2]);
MultiByteToWideChar(CP_ACP, 0, service_nameA, -1, service_nameW, _countof(service_nameW));
StringCbPrintfW(named_pipe_name, sizeof(named_pipe_name), L"\\\\.\\pipe\\%ls_pipe", service_nameW);
res = WaitNamedPipeW(named_pipe_name, NMPWAIT_USE_DEFAULT_WAIT);
if (!res)
return;
hClientPipe = CreateFileW(named_pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hClientPipe == INVALID_HANDLE_VALUE)
return;
service_trace("Service process starting...\n");
res = start_service(service_nameA, service_nameW);
service_trace("Service process stopped.\n");
CloseHandle(hClientPipe);
}
HRESULT AddGraphToRot(IUnknown *pUnkGraph, DWORD *pdwRegister)
{
IMoniker * pMoniker;
IRunningObjectTable *pROT;
if (FAILED(GetRunningObjectTable(0, &pROT)))
{
return E_FAIL;
}
WCHAR wsz[128];
StringCbPrintfW(wsz, sizeof(wsz), L"FilterGraph %08x pid %08x", (DWORD_PTR)pUnkGraph,
GetCurrentProcessId());
HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);
if (SUCCEEDED(hr))
{
hr = pROT->Register(0, pUnkGraph, pMoniker, pdwRegister);
pMoniker->Release();
}
pROT->Release();
return hr;
}
static
BOOL
MAIN_SaveSettings(VOID)
{
WINDOWPLACEMENT WndPl;
DWORD dwSize;
WCHAR buffer[100];
WndPl.length = sizeof(WndPl);
GetWindowPlacement(Globals.hMainWnd, &WndPl);
StringCbPrintfW(buffer, sizeof(buffer),
L"%d %d %d %d %d",
WndPl.rcNormalPosition.left,
WndPl.rcNormalPosition.top,
WndPl.rcNormalPosition.right,
WndPl.rcNormalPosition.bottom,
WndPl.showCmd);
dwSize = wcslen(buffer) * sizeof(WCHAR);
RegSetValueExW(Globals.hKeyPMSettings, L"Window", 0, REG_SZ, (LPBYTE)buffer, dwSize);
return TRUE;
}
/* This is the slowpoll function which gathers up network/hard drive
performance data for the random pool */
BOOL SlowPoll (void)
{
static int isWorkstation = -1;
static int cbPerfData = 0x10000;
HANDLE hDevice;
LPBYTE lpBuffer;
DWORD dwSize, status;
LPWSTR lpszLanW, lpszLanS;
int nDrive;
/* Find out whether this is an NT server or workstation if necessary */
if (isWorkstation == -1)
{
HKEY hKey;
if (RegOpenKeyEx (HKEY_LOCAL_MACHINE,
L"SYSTEM\\CurrentControlSet\\Control\\ProductOptions",
0, KEY_READ, &hKey) == ERROR_SUCCESS)
{
wchar_t szValue[32];
dwSize = sizeof (szValue);
isWorkstation = TRUE;
status = RegQueryValueEx (hKey, L"ProductType", 0, NULL,
(LPBYTE) szValue, &dwSize);
if (status == ERROR_SUCCESS && _wcsicmp (szValue, L"WinNT"))
/* Note: There are (at least) three cases for
ProductType: WinNT = NT Workstation,
ServerNT = NT Server, LanmanNT = NT Server
acting as a Domain Controller */
isWorkstation = FALSE;
RegCloseKey (hKey);
}
}
/* Initialize the NetAPI32 function pointers if necessary */
if (hNetAPI32 == NULL)
{
/* Obtain a handle to the module containing the Lan Manager
functions */
wchar_t dllPath[MAX_PATH];
if (GetSystemDirectory (dllPath, MAX_PATH))
{
StringCbCatW(dllPath, sizeof(dllPath), L"\\NETAPI32.DLL");
}
else
StringCbCopyW(dllPath, sizeof(dllPath), L"C:\\Windows\\System32\\NETAPI32.DLL");
hNetAPI32 = LoadLibrary (dllPath);
if (hNetAPI32 != NULL)
{
/* Now get pointers to the functions */
pNetStatisticsGet = (NETSTATISTICSGET) GetProcAddress (hNetAPI32,
"NetStatisticsGet");
pNetApiBufferSize = (NETAPIBUFFERSIZE) GetProcAddress (hNetAPI32,
"NetApiBufferSize");
pNetApiBufferFree = (NETAPIBUFFERFREE) GetProcAddress (hNetAPI32,
"NetApiBufferFree");
/* Make sure we got valid pointers for every NetAPI32
function */
if (pNetStatisticsGet == NULL ||
pNetApiBufferSize == NULL ||
pNetApiBufferFree == NULL)
{
/* Free the library reference and reset the
static handle */
FreeLibrary (hNetAPI32);
hNetAPI32 = NULL;
}
}
}
/* Get network statistics. Note: Both NT Workstation and NT Server
by default will be running both the workstation and server
services. The heuristic below is probably useful though on the
assumption that the majority of the network traffic will be via
the appropriate service */
lpszLanW = (LPWSTR) WIDE ("LanmanWorkstation");
lpszLanS = (LPWSTR) WIDE ("LanmanServer");
if (hNetAPI32 &&
pNetStatisticsGet (NULL,
isWorkstation ? lpszLanW : lpszLanS,
0, 0, &lpBuffer) == 0)
{
pNetApiBufferSize (lpBuffer, &dwSize);
RandaddBuf ((unsigned char *) lpBuffer, dwSize);
pNetApiBufferFree (lpBuffer);
}
/* Get disk I/O statistics for all the hard drives */
for (nDrive = 0;; nDrive++)
{
DISK_PERFORMANCE diskPerformance;
wchar_t szDevice[24];
/* Check whether we can access this device */
StringCbPrintfW (szDevice, sizeof(szDevice), L"\\\\.\\PhysicalDrive%d", nDrive);
hDevice = CreateFile (szDevice, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, 0, NULL);
if (hDevice == INVALID_HANDLE_VALUE)
break;
/* Note: This only works if you have turned on the disk
performance counters with 'diskperf -y'. These counters
are off by default */
if (DeviceIoControl (hDevice, IOCTL_DISK_PERFORMANCE, NULL, 0,
&diskPerformance, sizeof (DISK_PERFORMANCE),
&dwSize, NULL))
{
RandaddBuf ((unsigned char *) &diskPerformance, dwSize);
}
CloseHandle (hDevice);
}
// CryptoAPI: We always have a valid CryptoAPI context when we arrive here but
// we keep the check for clarity purpose
if ( !CryptoAPIAvailable )
return FALSE;
if (CryptGenRandom (hCryptProv, sizeof (buffer), buffer))
{
RandaddBuf (buffer, sizeof (buffer));
burn(buffer, sizeof (buffer));
Randmix();
return TRUE;
}
else
{
/* return error in case CryptGenRandom fails */
CryptoAPILastError = GetLastError ();
return FALSE;
}
}
