able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/win32/client/tth.c

1514 lines
35 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1990 Microsoft Corporation
Module Name:
old tth.c
Abstract:
Test program for Win32 Base File API calls
Author:
Mark Lucovsky (markl) 26-Sep-1990
Revision History:
--*/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <windows.h>
#include <string.h>
#include <memory.h>
#include <process.h>
#define xassert ASSERT
int izero;
int i,j;
#define BASESPIN 1000000
#define NULL_SERVER_SWITCHES 10000
#define PATH_CONVERSION_TEST 1000
//
// Define local types.
//
typedef struct _PERFINFO {
LARGE_INTEGER StartTime;
LARGE_INTEGER StopTime;
ULONG ContextSwitches;
ULONG FirstLevelFills;
ULONG SecondLevelFills;
ULONG SystemCalls;
PCHAR Title;
ULONG Iterations;
} PERFINFO, *PPERFINFO;
VOID
FinishBenchMark (
IN PPERFINFO PerfInfo
)
{
ULONG ContextSwitches;
LARGE_INTEGER Duration;
ULONG FirstLevelFills;
ULONG Length;
ULONG Performance;
ULONG SecondLevelFills;
NTSTATUS Status;
ULONG SystemCalls;
SYSTEM_PERFORMANCE_INFORMATION SystemInfo;
//
// Print results and announce end of test.
//
NtQuerySystemTime((PLARGE_INTEGER)&PerfInfo->StopTime);
Status = NtQuerySystemInformation(SystemPerformanceInformation,
(PVOID)&SystemInfo,
sizeof(SYSTEM_PERFORMANCE_INFORMATION),
NULL);
if (NT_SUCCESS(Status) == FALSE) {
printf("Failed to query performance information, status = %lx\n", Status);
return;
}
Duration = RtlLargeIntegerSubtract(PerfInfo->StopTime, PerfInfo->StartTime);
Length = Duration.LowPart / 10000;
printf(" Test time in milliseconds %d\n", Length);
printf(" Number of iterations %d\n", PerfInfo->Iterations);
Performance = PerfInfo->Iterations * 1000 / Length;
printf(" Iterations per second %d\n", Performance);
ContextSwitches = SystemInfo.ContextSwitches - PerfInfo->ContextSwitches;
FirstLevelFills = SystemInfo.FirstLevelTbFills - PerfInfo->FirstLevelFills;
SecondLevelFills = SystemInfo.SecondLevelTbFills - PerfInfo->SecondLevelFills;
SystemCalls = SystemInfo.SystemCalls - PerfInfo->SystemCalls;
printf(" First Level TB Fills %d\n", FirstLevelFills);
printf(" Second Level TB Fills %d\n", SecondLevelFills);
printf(" Total Context Switches %d\n", ContextSwitches);
printf(" Number of System Calls %d\n", SystemCalls);
printf("*** End of Test ***\n\n");
return;
}
VOID
StartBenchMark (
IN PCHAR Title,
IN ULONG Iterations,
IN PPERFINFO PerfInfo
)
{
NTSTATUS Status;
SYSTEM_PERFORMANCE_INFORMATION SystemInfo;
//
// Announce start of test and the number of iterations.
//
printf("*** Start of test ***\n %s\n", Title);
PerfInfo->Title = Title;
PerfInfo->Iterations = Iterations;
NtQuerySystemTime((PLARGE_INTEGER)&PerfInfo->StartTime);
Status = NtQuerySystemInformation(SystemPerformanceInformation,
(PVOID)&SystemInfo,
sizeof(SYSTEM_PERFORMANCE_INFORMATION),
NULL);
if (NT_SUCCESS(Status) == FALSE) {
printf("Failed to query performance information, status = %lx\n", Status);
return;
}
PerfInfo->ContextSwitches = SystemInfo.ContextSwitches;
PerfInfo->FirstLevelFills = SystemInfo.FirstLevelTbFills;
PerfInfo->SecondLevelFills = SystemInfo.SecondLevelTbFills;
PerfInfo->SystemCalls = SystemInfo.SystemCalls;
return;
}
VOID
ScrollTest()
{
COORD dest,cp;
SMALL_RECT Sm;
CHAR_INFO ci;
CONSOLE_SCREEN_BUFFER_INFO sbi;
HANDLE ScreenHandle;
SMALL_RECT Window;
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &sbi);
Window.Left = 0;
Window.Top = 0;
Window.Right = 79;
Window.Bottom = 49;
dest.X = 0;
dest.Y = 0;
ci.Char.AsciiChar = ' ';
ci.Attributes = sbi.wAttributes;
SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE),
TRUE,
&Window);
cp.X = 0;
cp.Y = 0;
Sm.Left = 0;
Sm.Top = 1;
Sm.Right = 79;
Sm.Bottom = 49;
ScrollConsoleScreenBuffer(GetStdHandle(STD_OUTPUT_HANDLE),
&Sm,
NULL,
dest,
&ci);
}
VOID
WinWordOpenFileTest()
{
PERFINFO PerfInfo;
ULONG Index;
OFSTRUCT ofstr;
HANDLE iFile;
StartBenchMark("WinWord OpenFile)",
3,
&PerfInfo);
for ( Index=0;Index<3;Index++){
iFile = (HANDLE)OpenFile("foo",&ofstr, OF_PARSE);
iFile = (HANDLE)OpenFile("E:\\xxxxxxx\\winword.ini",&ofstr, 0x20);
iFile = (HANDLE)OpenFile("E:\\xxxxxxx\\perftest.doc",&ofstr, 0x22);
iFile = (HANDLE)OpenFile("E:foo",&ofstr, OF_PARSE);
iFile = (HANDLE)OpenFile("E:foo",&ofstr, OF_PARSE);
iFile = (HANDLE)OpenFile("E:foo",&ofstr, OF_PARSE);
iFile = (HANDLE)OpenFile("E:foo",&ofstr, OF_PARSE);
iFile = (HANDLE)OpenFile("E:\\xxxxxxx\\custom.dic",&ofstr, 0x4022 );
iFile = (HANDLE)OpenFile("E:\\xxxxxxx\\sp_am.exc",&ofstr, 0x4040 );
iFile = (HANDLE)OpenFile("E:foo",&ofstr, OF_PARSE);
iFile = (HANDLE)OpenFile("foo",&ofstr, OF_PARSE);
iFile = (HANDLE)OpenFile("E:~doc3d08.tmp",&ofstr, 0x1022);
iFile = (HANDLE)OpenFile("E:\\xxxxxxx\\tempx.doc",&ofstr, 0xa022 );
iFile = (HANDLE)OpenFile("E:\\xxxxxxx\\~$rftest.doc",&ofstr, 0x4012 );
iFile = (HANDLE)OpenFile("foo",&ofstr, OF_PARSE);
iFile = (HANDLE)OpenFile("E:~doc391f.tmp",&ofstr, 0x1022);
iFile = (HANDLE)OpenFile("E:\\xxxxxxx\\tempy.doc",&ofstr, 0xa022 );
iFile = (HANDLE)OpenFile("E:\\xxxxxxx\\winword.ini",&ofstr, 0x12);
}
FinishBenchMark(&PerfInfo);
}
VOID
gettictst(int x)
{
PERFINFO PerfInfo;
ULONG i,j;
ULONG tnt,tw32;
if ( !x ) {
StartBenchMark("NtGetTickCount)",
100000,
&PerfInfo);
for ( i=0;i<100000;i++){
j = GetTickCount();
}
FinishBenchMark(&PerfInfo);
}
else {
while(1)GetTickCount();
}
}
VOID
latst()
{
PERFINFO PerfInfo;
ULONG i,j;
HANDLE h1, h2, h3, h4, h5;
StartBenchMark("LocalAlloc/Free)",
200,
&PerfInfo);
for ( i=0;i<200/5;i++){
h1 = LocalAlloc(0, 500);
h2 = LocalAlloc(0, 600);
h3 = LocalAlloc(0, 700);
LocalFree(h2);
h4 = LocalAlloc(0, 1000);
h5 = LocalAlloc(0, 100);
LocalFree(h1);
LocalFree(h3);
LocalFree(h4);
LocalFree(h5);
}
FinishBenchMark(&PerfInfo);
}
VOID
WinWordGetDriveTypeTest()
{
PERFINFO PerfInfo;
ULONG Index,Reps;
OFSTRUCT ofstr;
HANDLE iFile;
CHAR DiskName[4];
WCHAR WDiskName[4];
// StartBenchMark("WinWord GetDriveType (1-26)",
// 26,
// &PerfInfo);
//
// for ( Index=1;Index<27;Index++){
// GetDriveType(Index);
// }
//
// FinishBenchMark(&PerfInfo);
DiskName[0]='a';
DiskName[1]=':';
DiskName[2]='\\';
DiskName[3]='\0';
StartBenchMark("WinWord GetDriveTypeA (a-z)",
100,
&PerfInfo);
for(Reps=0;Reps<100;Reps++){
for ( Index=0;Index<26;Index++){
DiskName[0]='a'+Index;
GetDriveTypeA(DiskName);
}
}
FinishBenchMark(&PerfInfo);
WDiskName[0]=(WCHAR)'a';
WDiskName[1]=(WCHAR)':';
WDiskName[2]=(WCHAR)'\\';
WDiskName[3]=(WCHAR)'\0';
StartBenchMark("WinWord GetDriveTypeW (a-z)",
100,
&PerfInfo);
for(Reps=0;Reps<100;Reps++){
for ( Index=0;Index<26;Index++){
WDiskName[0]=(WCHAR)'a'+Index;
GetDriveTypeW(WDiskName);
}
}
FinishBenchMark(&PerfInfo);
}
VOID
BogusOrdinalTest()
{
HANDLE hBase;
FARPROC z;
WaitForSingleObject(0,-2);
hBase = GetModuleHandle("base");
xassert(hBase);
z = GetProcAddress(hBase,0x00001345);
}
VOID
NullServerSwitchTest (
VOID
)
{
PERFINFO PerfInfo;
NTSTATUS Status;
ULONG Index;
StartBenchMark("Null Server Call Benchmark)",
NULL_SERVER_SWITCHES,
&PerfInfo);
for (Index = 0; Index < NULL_SERVER_SWITCHES; Index += 1) {
CsrIdentifyAlertableThread();
}
//
// Print out performance statistics.
//
FinishBenchMark(&PerfInfo);
return;
}
VOID
PathConvertTest (
VOID
)
{
PERFINFO PerfInfo;
NTSTATUS Status;
ULONG Index;
UNICODE_STRING FileName;
BOOLEAN TranslationStatus;
RTL_RELATIVE_NAME RelativeName;
StartBenchMark("Path Conversion Test (foo)",
PATH_CONVERSION_TEST,
&PerfInfo);
for (Index = 0; Index < PATH_CONVERSION_TEST; Index += 1) {
RtlDosPathNameToNtPathName_U(
L"foo",
&FileName,
NULL,
&RelativeName
);
RtlFreeHeap(RtlProcessHeap(),FileName.Buffer);
}
//
// Print out performance statistics.
//
FinishBenchMark(&PerfInfo);
StartBenchMark("Path Conversion Test (e:\\nt\\windows\\foo)",
PATH_CONVERSION_TEST,
&PerfInfo);
for (Index = 0; Index < PATH_CONVERSION_TEST; Index += 1) {
RtlDosPathNameToNtPathName_U(
L"e:\\nt\\windows\\foo",
&FileName,
NULL,
&RelativeName
);
RtlFreeHeap(RtlProcessHeap(),FileName.Buffer);
}
//
// Print out performance statistics.
//
FinishBenchMark(&PerfInfo);
return;
}
z(){}
bar()
{
for (i=0;i<2*BASESPIN;i++)j = i++;
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
}
foo()
{
for (i=0;i<BASESPIN;i++)j = i++;
bar();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
}
proftst()
{
for (i=0;i<BASESPIN;i++)j = i++;
foo();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
z();
}
VOID
probtst(
VOID
)
{
LPVOID ReadOnly;
LPVOID ReadWrite;
LPVOID ReadWrite2;
LPVOID NoReadWrite;
LPVOID MappedReadWrite;
LPVOID p;
HANDLE MappedFile;
LPSTR l;
LPWSTR w;
BOOL b;
ReadOnly = VirtualAlloc(NULL,4096,MEM_COMMIT,PAGE_READONLY);
ASSERT(ReadOnly);
ASSERT(!IsBadReadPtr(ReadOnly,1024));
ASSERT(!IsBadReadPtr(ReadOnly,4096));
ASSERT(IsBadReadPtr(ReadOnly,4097));
ASSERT(!IsBadHugeReadPtr(ReadOnly,1024));
ASSERT(!IsBadHugeReadPtr(ReadOnly,4096));
ASSERT(IsBadHugeReadPtr(ReadOnly,4097));
ASSERT(IsBadWritePtr(ReadOnly,1024));
ASSERT(IsBadWritePtr(ReadOnly,4096));
ASSERT(IsBadWritePtr(ReadOnly,4097));
ASSERT(IsBadHugeWritePtr(ReadOnly,1024));
ASSERT(IsBadHugeWritePtr(ReadOnly,4096));
ASSERT(IsBadHugeWritePtr(ReadOnly,4097));
ReadWrite = VirtualAlloc(NULL,4096,MEM_COMMIT,PAGE_READWRITE);
ASSERT(ReadWrite);
ASSERT(!IsBadReadPtr(ReadWrite,1024));
ASSERT(!IsBadReadPtr(ReadWrite,4096));
ASSERT(IsBadReadPtr(ReadWrite,4097));
ASSERT(!IsBadHugeReadPtr(ReadWrite,1024));
ASSERT(!IsBadHugeReadPtr(ReadWrite,4096));
ASSERT(IsBadHugeReadPtr(ReadWrite,4097));
ASSERT(!IsBadWritePtr(ReadWrite,1024));
ASSERT(!IsBadWritePtr(ReadWrite,4096));
ASSERT(IsBadWritePtr(ReadWrite,4097));
ASSERT(!IsBadHugeWritePtr(ReadWrite,1024));
ASSERT(!IsBadHugeWritePtr(ReadWrite,4096));
ASSERT(IsBadHugeWritePtr(ReadWrite,4097));
NoReadWrite = VirtualAlloc(NULL,4096,MEM_COMMIT,PAGE_NOACCESS);
ASSERT(NoReadWrite);
ASSERT(IsBadReadPtr(NoReadWrite,1024));
ASSERT(IsBadReadPtr(NoReadWrite,4096));
ASSERT(IsBadReadPtr(NoReadWrite,4097));
ASSERT(IsBadHugeReadPtr(NoReadWrite,1024));
ASSERT(IsBadHugeReadPtr(NoReadWrite,4096));
ASSERT(IsBadHugeReadPtr(NoReadWrite,4097));
ASSERT(IsBadWritePtr(NoReadWrite,1024));
ASSERT(IsBadWritePtr(NoReadWrite,4096));
ASSERT(IsBadWritePtr(NoReadWrite,4097));
ASSERT(IsBadHugeWritePtr(NoReadWrite,1024));
ASSERT(IsBadHugeWritePtr(NoReadWrite,4096));
ASSERT(IsBadHugeWritePtr(NoReadWrite,4097));
l = ReadWrite;
l[4092]='a';
l[4093]='b';
l[4094]='c';
l[4095]='\0';
ASSERT(!IsBadStringPtrA(&l[4092],2));
ASSERT(!IsBadStringPtrA(&l[4092],3));
ASSERT(!IsBadStringPtrA(&l[4092],4));
ASSERT(!IsBadStringPtrA(&l[4092],5));
l[4095]='d';
ASSERT(!IsBadStringPtrA(&l[4092],2));
ASSERT(!IsBadStringPtrA(&l[4092],3));
ASSERT(!IsBadStringPtrA(&l[4092],4));
ASSERT(IsBadStringPtrA(&l[4092],5));
w = ReadWrite;
w[2044]=(WCHAR)'a';
w[2045]=(WCHAR)'b';
w[2046]=(WCHAR)'c';
w[2047]=UNICODE_NULL;
ASSERT(!IsBadStringPtrW(&w[2044],2));
ASSERT(!IsBadStringPtrW(&w[2044],3));
ASSERT(!IsBadStringPtrW(&w[2044],4));
ASSERT(!IsBadStringPtrW(&w[2044],5));
w[2047]=(WCHAR)'d';
ASSERT(!IsBadStringPtrW(&w[2044],2));
ASSERT(!IsBadStringPtrW(&w[2044],3));
ASSERT(!IsBadStringPtrW(&w[2044],4));
ASSERT(IsBadStringPtrW(&w[2044],5));
ReadWrite2 = VirtualAlloc(NULL,4096,MEM_COMMIT,PAGE_READWRITE);
ASSERT(ReadWrite2);
ASSERT(VirtualLock(ReadWrite2,4096));
ASSERT(VirtualUnlock(ReadWrite2,4));
ASSERT(!VirtualUnlock(ReadWrite2,4));
ASSERT(!VirtualLock(ReadWrite2,4097));
ASSERT(!VirtualUnlock(ReadWrite2,4097));
ASSERT(VirtualLock(ReadWrite2,4096));
ASSERT(VirtualUnlock(ReadWrite2,4096));
ASSERT(!VirtualUnlock(ReadWrite2,4096));
MappedFile = CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,8192,NULL);
ASSERT(MappedFile);
MappedReadWrite = MapViewOfFileEx(MappedFile,FILE_MAP_WRITE,0,0,0,(LPVOID)0x50000000);
ASSERT(MappedReadWrite);
p = MapViewOfFileEx(MappedFile,FILE_MAP_WRITE,0,0,0,(LPVOID)GetModuleHandle(NULL));
ASSERT(!p);
ASSERT(SetPriorityClass(GetCurrentProcess(),IDLE_PRIORITY_CLASS));
ASSERT(GetPriorityClass(GetCurrentProcess()) == IDLE_PRIORITY_CLASS);
ASSERT(SetPriorityClass(GetCurrentProcess(),NORMAL_PRIORITY_CLASS));
ASSERT(GetPriorityClass(GetCurrentProcess()) == NORMAL_PRIORITY_CLASS);
ASSERT(SetPriorityClass(GetCurrentProcess(),HIGH_PRIORITY_CLASS));
ASSERT(GetPriorityClass(GetCurrentProcess()) == HIGH_PRIORITY_CLASS);
ASSERT(SetPriorityClass(GetCurrentProcess(),NORMAL_PRIORITY_CLASS));
ASSERT(GetPriorityClass(GetCurrentProcess()) == NORMAL_PRIORITY_CLASS);
}
void
notifytst()
{
HANDLE nHandle;
DWORD wret;
HANDLE fFile;
WIN32_FIND_DATA FindFileData;
int n;
BOOL b;
fFile = FindFirstFile(
"c:\\*.*",
&FindFileData
);
xassert(fFile != INVALID_HANDLE_VALUE);
n = 0;
b = TRUE;
while(b) {
n++;
b = FindNextFile(fFile,&FindFileData);
}
FindClose(fFile);
printf("%d files\n",n);
nHandle = FindFirstChangeNotification(
"C:\\",
TRUE,
FILE_NOTIFY_CHANGE_NAME
);
xassert(nHandle != INVALID_HANDLE_VALUE);
wret = WaitForSingleObject(nHandle,-1);
xassert(wret == 0);
fFile = FindFirstFile(
"c:\\*.*",
&FindFileData
);
xassert(fFile != INVALID_HANDLE_VALUE);
n = 0;
b = TRUE;
while(b) {
n++;
b = FindNextFile(fFile,&FindFileData);
}
FindClose(fFile);
printf("%d files\n",n);
b = FindNextChangeNotification(nHandle);
xassert(b);
wret = WaitForSingleObject(nHandle,-1);
xassert(wret == 0);
fFile = FindFirstFile(
"c:\\*.*",
&FindFileData
);
xassert(fFile != INVALID_HANDLE_VALUE);
n = 0;
b = TRUE;
while(b) {
n++;
b = FindNextFile(fFile,&FindFileData);
}
FindClose(fFile);
printf("%d files\n",n);
xassert(FindCloseChangeNotification(nHandle));
xassert(!FindCloseChangeNotification(nHandle));
}
void
openiftst()
{
HANDLE NEvent, NSemaphore, NMutex;
HANDLE sEvent, sSemaphore, sMutex;
NEvent = CreateEvent(NULL,TRUE,TRUE,"named-event");
xassert(NEvent);
xassert(GetLastError()==0);
sEvent = CreateEvent(NULL,TRUE,TRUE,"named-event");
xassert(sEvent);
xassert(GetLastError()==ERROR_ALREADY_EXISTS);
NSemaphore = CreateSemaphore(NULL,1,256,"named-event");
NSemaphore = CreateSemaphore(NULL,1,256,"named-semaphore");
xassert(NSemaphore);
xassert(GetLastError()==0);
sSemaphore = CreateSemaphore(NULL,1,256,"named-semaphore");
xassert(sSemaphore);
xassert(GetLastError()==ERROR_ALREADY_EXISTS);
NMutex = CreateMutex(NULL,FALSE,"named-mutex");
xassert(NMutex);
xassert(GetLastError()==0);
sMutex = CreateMutex(NULL,FALSE,"named-mutex");
xassert(sMutex);
xassert(GetLastError()==ERROR_ALREADY_EXISTS);
}
void
NewRip(int flag, LPSTR str)
{
DWORD ExceptionArguments[3];
try {
ExceptionArguments[0]=strlen(str);
ExceptionArguments[1]=(DWORD)str;
ExceptionArguments[2]=(DWORD)flag;
RaiseException(0x0eab7190,0,3,ExceptionArguments);
}
except(EXCEPTION_EXECUTE_HANDLER) {
;
}
}
void
Ofprompt()
{
HFILE h;
OFSTRUCT of;
SetErrorMode(SEM_NOOPENFILEERRORBOX);
h = OpenFile("e:\\nt\\xt.cfg",&of,OF_PROMPT);
printf("OpenFile(e:\\nt\\xt.cfg) h = %lx, GLE = %d\n",h,GetLastError());
h = OpenFile("e:\\zznt\\xt.cfg",&of,OF_PROMPT);
printf("OpenFile(e:\\zznt\\xt.cfg) h = %lx, GLE = %d\n",h,GetLastError());
h = OpenFile("e:\\nt\\xt.cfg",&of,OF_PROMPT | OF_CANCEL);
printf("OpenFile(e:\\nt\\xt.cfg) h = %lx, GLE = %d\n",h,GetLastError());
SetErrorMode(0);
h = OpenFile("e:\\nt\\xt.cfg",&of,OF_PROMPT);
printf("OpenFile(e:\\nt\\xt.cfg) h = %lx, GLE = %d\n",h,GetLastError());
h = OpenFile("e:\\zznt\\xt.cfg",&of,OF_PROMPT);
printf("OpenFile(e:\\zznt\\xt.cfg) h = %lx, GLE = %d\n",h,GetLastError());
h = OpenFile("e:\\nt\\xt.cfg",&of,OF_PROMPT | OF_CANCEL);
printf("OpenFile(e:\\nt\\xt.cfg) h = %lx, GLE = %d\n",h,GetLastError());
}
void
rtldevn()
{
UNICODE_STRING ustr;
ANSI_STRING astr;
CHAR buf[256];
DWORD dw;
printf("name -> ");
scanf("%s",buf);
RtlInitAnsiString(&astr,buf);
RtlAnsiStringToUnicodeString(&ustr,&astr,TRUE);
dw = RtlIsDosDeviceName_U(ustr.Buffer);
printf("dw %x Name %s \n",dw,buf);
}
typedef struct _CMDSHOW {
WORD wMustBe2;
WORD wShowWindowValue;
} CMDSHOW, *PCMDSHOW;
typedef struct _LOAD_MODULE_PARAMS {
LPSTR lpEnvAddress;
LPSTR lpCmdLine;
PCMDSHOW lpCmdShow;
DWORD dwReserved;
} LOAD_MODULE_PARAMS, *PLOAD_MODULE_PARAMS;
typedef DWORD (*PFNWAITFORINPUTIDLE)(HANDLE hProcess, DWORD dwMilliseconds);
void
cptst()
{
CHAR buf[256];
CHAR cline[256];
DWORD dw;
STARTUPINFO StartupInfo;
PROCESS_INFORMATION ProcessInformation;
LOAD_MODULE_PARAMS lmp;
CHAR Environment[256];
CMDSHOW cs;
PFNWAITFORINPUTIDLE WaitForInputIdleRoutine;
HANDLE hMod;
hMod = LoadLibrary("user32");
WaitForInputIdleRoutine = GetProcAddress(hMod,"WaitForInputIdle");
printf("name -> ");
scanf("%s",buf);
RtlZeroMemory(&StartupInfo,sizeof(StartupInfo));
StartupInfo.cb = sizeof(StartupInfo);
SetLastError(0);
CreateProcess(
NULL,
buf,
NULL,
NULL,
FALSE,
0,
NULL,
NULL,
&StartupInfo,
&ProcessInformation
);
(WaitForInputIdleRoutine)(ProcessInformation.hProcess,10000);
printf("GLE %d\n",GetLastError());
SetLastError(0);
printf("WINEXEC %d\n",WinExec(buf,0));
SetLastError(0);
lmp.lpEnvAddress = Environment;
lmp.lpCmdLine = cline;
lmp.dwReserved = 0;
lmp.lpCmdShow = &cs;
cs.wMustBe2 = 2;
cs.wShowWindowValue = 3;
cline[0] = strlen(buf);
RtlMoveMemory(&cline[1],buf,cline[0]);
cline[cline[0]+1] = 0x0d;
printf("LOADMOD %d\n",LoadModule(buf,&lmp));
}
void
spawntst()
{
CHAR buf[256];
int i;
printf("name -> ");
scanf("%s",buf);
i = _spawnlp(_P_WAIT,buf,"-l",NULL);
}
void
badproctst()
{
CHAR buf[256];
DWORD dw;
STARTUPINFO StartupInfo;
PROCESS_INFORMATION ProcessInformation;
LOAD_MODULE_PARAMS lmp;
CHAR Environment[256];
CMDSHOW cs;
printf("name -> ");
scanf("%s",buf);
RtlZeroMemory(&StartupInfo,sizeof(StartupInfo));
StartupInfo.cb = sizeof(StartupInfo);
SetLastError(0);
CreateProcess(
NULL,
buf,
NULL,
NULL,
FALSE,
0,
NULL,
"*",
&StartupInfo,
&ProcessInformation
);
printf("GLE %d\n",GetLastError());
}
void
copytst()
{
CHAR src[256];
CHAR dst[256];
BOOL b;
printf("src -> ");
scanf("%s",src);
printf("dst -> ");
scanf("%s",dst);
b = CopyFile(src,dst,FALSE);
}
void
fftst()
{
CHAR buf[256];
HANDLE fFile;
WIN32_FIND_DATA FindFileData;
BOOL b;
printf("pattern -> ");
scanf("%s",buf);
fFile = FindFirstFile(
buf,
&FindFileData
);
if ( fFile == INVALID_HANDLE_VALUE ){
printf("findfirst %s failed %d\n",buf,GetLastError());
return;
}
b = TRUE;
while(b) {
printf("0x%08x %08d %s\n",
FindFileData.dwFileAttributes,
FindFileData.nFileSizeLow,
FindFileData.cFileName
);
b = FindNextFile(fFile,&FindFileData);
}
FindClose(fFile);
}
void
oftst()
{
OFSTRUCT OfStruct;
HFILE rv;
rv = OpenFile("",&OfStruct, OF_EXIST);
printf("rv %d\n",rv);
rv = OpenFile(NULL,&OfStruct, OF_EXIST);
printf("rv %d\n",rv);
rv = OpenFile(" ",&OfStruct, OF_EXIST);
printf("rv %d\n",rv);
}
void
spath()
{
char cbuff[512];
SearchPath(
"c:\\nt;c:\\xytty;c:\\nt\\system",
"kernel32",
".dll",
512,
cbuff,
NULL
);
printf("%s\n",cbuff);
}
void
muldivtst()
{
int answer,number,numerator,denom,result;
PERFINFO PerfInfo;
ULONG Index;
StartBenchMark("MulDiv)",
50000,
&PerfInfo);
for(Index=0;Index<50000;Index++){
//
// answer = -24
//
number = -18;
numerator = 96;
denom = 72;
answer = -24;
result = MulDiv(number,numerator,denom);
if ( answer != result ) printf("MulDiv(%ld,%ld,%ld)=%ld %s\n",number,numerator,denom,result,answer == result ? "SUCCESS" : "FAILED");
//
// answer = -24
//
number = 18;
numerator = -96;
denom = 72;
answer = -24;
result = MulDiv(number,numerator,denom);
if ( answer != result ) printf("MulDiv(%ld,%ld,%ld)=%ld %s\n",number,numerator,denom,result,answer == result ? "SUCCESS" : "FAILED");
//
// answer = 24
//
number = -18;
numerator = -96;
denom = 72;
answer = 24;
result = MulDiv(number,numerator,denom);
if ( answer != result ) printf("MulDiv(%ld,%ld,%ld)=%ld %s\n",number,numerator,denom,result,answer == result ? "SUCCESS" : "FAILED");
//
// answer = -24
//
number = -18;
numerator = -96;
denom = -72;
answer = -24;
result = MulDiv(number,numerator,denom);
if ( answer != result ) printf("MulDiv(%ld,%ld,%ld)=%ld %s\n",number,numerator,denom,result,answer == result ? "SUCCESS" : "FAILED");
//
// answer = -24
//
number = -18;
numerator = -96;
denom = -72;
answer = -24;
result = MulDiv(number,numerator,denom);
if ( answer != result ) printf("MulDiv(%ld,%ld,%ld)=%ld %s\n",number,numerator,denom,result,answer == result ? "SUCCESS" : "FAILED");
//
// answer = 24
//
number = 18;
numerator = -96;
denom = -72;
answer = 24;
result = MulDiv(number,numerator,denom);
if ( answer != result ) printf("MulDiv(%ld,%ld,%ld)=%ld %s\n",number,numerator,denom,result,answer == result ? "SUCCESS" : "FAILED");
//
// answer = 2
//
number = 4;
numerator = 2;
denom = 5;
answer = 2;
result = MulDiv(number,numerator,denom);
if ( answer != result ) printf("MulDiv(%ld,%ld,%ld)=%ld %s\n",number,numerator,denom,result,answer == result ? "SUCCESS" : "FAILED");
//
// answer = 500
//
number = 100;
numerator = 10;
denom = 2;
answer = 500;
result = MulDiv(number,numerator,denom);
if ( answer != result ) printf("MulDiv(%ld,%ld,%ld)=%ld %s\n",number,numerator,denom,result,answer == result ? "SUCCESS" : "FAILED");
//
// answer = 3b9aca00
//
number = 1000000;
numerator = 1000000;
denom = 1000;
answer = 0x3b9aca00;
result = MulDiv(number,numerator,denom);
if ( answer != result ) printf("MulDiv(%ld,%ld,%ld)=0x%lx %s\n",number,numerator,denom,result,answer == result ? "SUCCESS" : "FAILED");
}
FinishBenchMark(&PerfInfo);
}
void
dname()
{
UNICODE_STRING LinkName;
UNICODE_STRING DeviceName;
OBJECT_ATTRIBUTES Obja;
HANDLE LinkHandle;
NTSTATUS Status;
ULONG i;
PWCHAR p;
WCHAR DeviceNameBuffer[MAXIMUM_FILENAME_LENGTH];
RtlInitUnicodeString(&LinkName,L"\\DosDevices\\A:");
p = (PWCHAR)LinkName.Buffer;
p = p+12;
for(i=0;i<26;i++){
*p = (WCHAR)'A'+i;
InitializeObjectAttributes(
&Obja,
&LinkName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
Status = NtOpenSymbolicLinkObject(
&LinkHandle,
SYMBOLIC_LINK_QUERY,
&Obja
);
if (NT_SUCCESS( Status )) {
//
// Open succeeded, Now get the link value
//
DeviceName.Length = 0;
DeviceName.MaximumLength = sizeof(DeviceNameBuffer);
DeviceName.Buffer = DeviceNameBuffer;
Status = NtQuerySymbolicLinkObject(
LinkHandle,
&DeviceName,
NULL
);
NtClose(LinkHandle);
if ( NT_SUCCESS(Status) ) {
printf("%wZ -> %wZ\n",&LinkName,&DeviceName);
}
}
}
}
void
mfextst()
{
MoveFileExW(L"C:\\tmp\\xx.xx", NULL, MOVEFILE_DELAY_UNTIL_REBOOT);
}
CRITICAL_SECTION cs;
VOID
StartBounce(PVOID pThreadBlockInfo)
{
EnterCriticalSection(&cs);
Sleep(-1);
}
void
lockuptst()
{
HANDLE hThread;
DWORD id;
InitializeCriticalSection(&cs);
hThread = CreateThread(
NULL,
0,
(LPTHREAD_START_ROUTINE)StartBounce,
0,
0,
&id
);
EnterCriticalSection(&cs);
Sleep(-1);
}
void
getdisktst()
{
BOOL b;
DWORD spc,bps,fc,tc;
b = GetDiskFreeSpace(NULL,&spc,&bps,&fc,&tc);
printf("GetDiskFreeSpace NULL %s\n",b ? "WORKED" : "FAILED" );
b = GetDiskFreeSpace("C:\\",&spc,&bps,&fc,&tc);
printf("GetDiskFreeSpace C:\\ %s\n",b ? "WORKED" : "FAILED" );
b = GetDiskFreeSpace("C:\\WINNT\\",&spc,&bps,&fc,&tc);
printf("GetDiskFreeSpace C:\\winnt\\ %s\n",b ? "WORKED" : "FAILED" );
}
void
DoChoice(
int Choice
)
{
NTSTATUS Status;
LONG *p;
top:
printf("exception test\n");
printf("1 Access Violation(r)\n");
printf("2 Access Violation(w)\n");
printf("3 Array Bounds \n");
printf("4 Int Divide By Zero\n");
printf("5 Software 0x77\n");
printf("6 bigpath\n");
printf("7 set default harderror\n");
printf("8 proftests\n");
printf("9 probetests\n");
printf("10 notifytests\n");
printf("11 openif\n");
printf("12 null server\n");
printf("13 path convert\n");
printf("14 bogus ordinal\n");
printf("15 winword openfile\n");
printf("16 scroll test\n");
printf("17 winword getdrivetype\n");
printf("18 dorip\n");
printf("19 Ofprompt\n");
printf("20 rtldevn\n");
printf("21 cptst\n");
printf("22 oftst\n");
printf("23 dname\n");
printf("24 fftst\n");
printf("25 copy\n");
printf("26 badproc\n");
printf("27 loadlib\n");
printf("28 gettictst(0)\n");
printf("29 latst\n");
printf("30 gettictst(1)\n");
printf("31 spath\n");
printf("32 spawntst\n");
printf("33 muldivtst\n");
printf("34 mfextst\n");
printf("35 lockuptst\n");
printf("36 getdisktst\n");
printf("Enter Choice --> ");
scanf("%d",&Choice);
printf("Good Choice... %d\n",Choice);
switch ( Choice ) {
case 1:
SetErrorMode(SEM_NOGPFAULTERRORBOX);
printf("Good Choice... %d\n",Choice);
p = (int *)0xbaadadd0;
Choice = *p;
break;
case 2:
printf("Good Choice... %d\n",Choice);
p = (int *)0xbaadadd0;
*p = Choice;
break;
case 3:
printf("Good Choice... %d\n",Choice);
RtlRaiseStatus(STATUS_ARRAY_BOUNDS_EXCEEDED);
break;
case 4:
printf("Good Choice... %d\n",Choice);
Choice = Choice/izero;
break;
case 5:
printf("Good Choice... %d\n",Choice);
{
UINT b;
b = SetErrorMode(SEM_FAILCRITICALERRORS);
xassert(b == 0);
b = SetErrorMode(0);
xassert(b == SEM_FAILCRITICALERRORS);
}
RtlRaiseStatus(0x77);
break;
case 6:
printf("Good Choice... %d\n",Choice);
{
DWORD Bsize;
DWORD Rsize;
LPSTR Buff;
LPSTR Ruff;
DWORD Rvalue;
LPSTR whocares;
int i;
printf("Enter Size --> ");
scanf("%d",&Bsize);
printf("Enter RSize --> ");
scanf("%d",&Rsize);
Buff = LocalAlloc(0,Bsize+1);
xassert(Buff);
Ruff = LocalAlloc(0,Bsize+1);
xassert(Buff);
RtlFillMemory(Buff,Bsize,'a');
Buff[0]='c';
Buff[1]=':';
Buff[2]='\\';
Buff[Bsize+1] = '\0';
Rvalue = GetFullPathName(Buff,Rsize,Ruff,&whocares);
i = strcmp(Buff,Ruff);
printf("Bsize %d Rsize %d Rvalue %d i=%d \n",Bsize,Rsize,Rvalue,i);
}
break;
case 7:
printf("Good Choice... %d\n",Choice);
Status = NtSetDefaultHardErrorPort(NULL);
xassert(Status == STATUS_PRIVILEGE_NOT_HELD);
break;
case 8:
printf("Good Choice... %d\n",Choice);
proftst();
break;
case 9:
printf("Good Choice... %d\n",Choice);
probtst();
break;
case 10:
printf("Good Choice... %d\n",Choice);
notifytst();
break;
case 11:
printf("Good Choice... %d\n",Choice);
openiftst();
break;
case 12:
printf("Good Choice... %d\n",Choice);
NullServerSwitchTest();
break;
case 13:
PathConvertTest();
break;
case 14:
BogusOrdinalTest();
break;
case 15:
WinWordOpenFileTest();
break;
case 16:
ScrollTest();
break;
case 17:
WinWordGetDriveTypeTest();
break;
case 18:
NewRip(0,"Just a warning\n");
NewRip(1,"We Are Hosed\n");
break;
case 19:
Ofprompt();
break;
case 20:
rtldevn();
break;
case 21:
cptst();
break;
case 22:
oftst();
break;
case 23:
dname();
break;
case 24:
fftst();
break;
case 25:
copytst();
break;
case 26:
badproctst();
break;
case 27:
{
HANDLE hmods,hmodc,hmodw;
hmods = LoadLibrary("shell32");
hmodc = LoadLibrary("cmd.exe");
hmodw = LoadLibrary("winspool.drv");
FreeLibrary(hmods);
FreeLibrary(hmodc);
FreeLibrary(hmodw);
}
break;
case 28:
gettictst(0);
break;
case 29:
latst();
break;
case 30:
gettictst(1);
break;
case 31:
spath();
break;
case 32:
spawntst();
break;
case 33:
muldivtst();
break;
case 34:
mfextst();
break;
case 35:
lockuptst();
break;
case 36:
getdisktst();
break;
default:
printf( "Bad choice: %d\n", Choice );
return;
}
return;
}
//#define NtCurrentTebAsm() {PTEB Teb;_asm{mov eax,fs:[0x24]};,Teb;}
DWORD
_cdecl
main(
int argc,
char *argv[],
char *envp[]
)
{
int Choice;
char b[512];
// PTEB x;
//
// x = NtCurrentTebAsm();
GetDriveTypeW(L"A:\\");
xassert(SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_HIGHEST));
xassert(GetThreadPriority(GetCurrentThread()) == THREAD_PRIORITY_HIGHEST);
xassert(SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_LOWEST));
xassert(GetThreadPriority(GetCurrentThread()) == THREAD_PRIORITY_LOWEST);
xassert(SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_ABOVE_NORMAL));
xassert(GetThreadPriority(GetCurrentThread()) == THREAD_PRIORITY_ABOVE_NORMAL);
xassert(SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_BELOW_NORMAL));
xassert(GetThreadPriority(GetCurrentThread()) == THREAD_PRIORITY_BELOW_NORMAL);
xassert(SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_NORMAL));
xassert(GetThreadPriority(GetCurrentThread()) == THREAD_PRIORITY_NORMAL);
xassert(SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_IDLE));
xassert(GetThreadPriority(GetCurrentThread()) == THREAD_PRIORITY_IDLE);
xassert(SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_TIME_CRITICAL));
xassert(GetThreadPriority(GetCurrentThread()) == THREAD_PRIORITY_TIME_CRITICAL);
xassert(SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_NORMAL));
xassert(GetThreadPriority(GetCurrentThread()) == THREAD_PRIORITY_NORMAL);
xassert(!SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_HIGHEST+1));
xassert(GetThreadPriority(GetCurrentProcess()) == THREAD_PRIORITY_ERROR_RETURN);
SetErrorMode(0);
GetSystemDirectory(b,512);
printf("%s\n",b);
GetWindowsDirectory(b,512);
printf("%s\n",b);
printf("TEBSIZE %d\n",sizeof(TEB));
Choice = GetModuleFileName(NULL,b,512);
if ( strlen(b) != Choice ) {
printf("BAD strlen(b) = %d Choice %d b= %s\n",strlen(b),Choice,b);
}
else {
printf("OK strlen(b) = %d Choice %d b= %s\n",strlen(b),Choice,b);
}
if (argc > 1) {
while (--argc) {
DoChoice( atoi( *++argv ) );
}
}
else {
while (TRUE) {
DoChoice( Choice );
}
}
//GetUserNameW(b,1);
return 0;
}
Reference in a new issue Copy permalink