C / C++ / MFC

CmyLife wrote:

Is is possible to get the names of the kernel system calls?

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

std::set<std::string> s;
 s.insert("Hello");

std:string TestCmd = "Hellooooooooo";
if (s.find(TestCmd) == s.end()){
   // Your property name isnt in the property set list    
}

RECT r;
GetWindowRect(hWnd, &r);
int Wth = r.right - r.left;
int Ht = r.bottom - r.top;

BITMAPINFOHEADER BMIH;
BMIH.biSize = sizeof(BITMAPINFOHEADER);
BMIH.biBitCount = 24;
BMIH.biPlanes = 1;
BMIH.biCompression = BI_RGB;
BMIH.biWidth = Wth;
BMIH.biHeight = Ht;
BMIH.biSizeImage = ((((BMIH.biWidth * BMIH.biBitCount)+ 31) & ~31) >> 3) * BMIH.biHeight;

char* myBits = malloc(BMIH.biSizeImage);
CreateDIBSection(hDC, (CONST BITMAPINFO*)&BMIH, DIB_RGB_COLORS, (void**)&myBits, NULL, 0);

FILE *pFile = fopen(  /* some Name  */,  "wb");
BITMAPFILEHEADER bmfh;
int nBitsOffset = sizeof(BITMAPFILEHEADER) + BMIH.biSize; 
LONG lImageSize = BMIH.biSizeImage;
LONG lFileSize = nBitsOffset + lImageSize;
bmfh.bfType = 'B'+('M'<<8);
bmfh.bfOffBits = nBitsOffset;
bmfh.bfSize = lFileSize;
bmfh.bfReserved1 = bmfh.bfReserved2 = 0;
// Write bitmap file header
UINT nWrittenFileHeaderSize = fwrite(&bmfh, 1, sizeof(BITMAPFILEHEADER), pFile);
// Write bitmap info header
UINT nWrittenInfoHeaderSize = fwrite(&BMIH, 1, sizeof(BITMAPINFOHEADER), pFile);
// Write our data we got back 
UINT nWrittenDIBDataSize = fwrite(myBits, 1, lImageSize, pFile);
// Close the file
fclose(pFile); 

ForNow wrote:

go to disassembly mode

ForNow wrote:

It's the handle I guess the next step is to go to disassembly mode and see

!handle	displays information about a handle or handles that one or all processes in the target system own.

0:000> !handle c0dedbad f
Handle 38
 Type Mutant
 Attributes 0
 GrantedAccess 0x1f0001:
 Delete,ReadControl,WriteDac,WriteOwner,Synch
 QueryState
 HandleCount 1
 PointerCount 96605
 Name <none>
 Object Specific Information
 Mutex is Owned
 Mutant Owner 11bc.1418

//Windows 8.1 and below:
BOOL IsValidHandle(HANDLE h)
{
	DWORD dwFlags = 0;
	return GetHandleInformation(h,&dwFlags);
}

//Windows 10 and above:
BOOL IsValidHandle(HANDLE h)
{
	return CompareObjectHandles(h,h);
}

if (IsValidHandle(h))
{
	DWORD dwResult = ::WaitForSingleObject(h, INFINITE);
	DWORD dwError = GetLastError();
}

Two or more processes can call CreateMutex to create the same named mutex. The first process actually creates the mutex, and subsequent processes open a handle to the existing mutex. This enables multiple processes to get handles of the same mutex, while relieving the user of the responsibility of ensuring that the creating process is started first. When using this technique, you should set the bInitialOwner flag to FALSE; otherwise, it can be difficult to be certain which process has initial ownership.

The creating thread can use the bInitialOwner flag to request immediate ownership of the mutex. Otherwise, a thread must use one of the wait functions to request ownership. When the mutex's state is signaled, one waiting thread is granted ownership, the mutex's state changes to nonsignaled, and the wait function returns. Only one thread can own a mutex at any given time. The owning thread uses the ReleaseMutex function to release its ownership.

If lpName matches the name of an existing event, semaphore, waitable timer, job, or file-mapping object, the function fails and the GetLastError function returns ERROR_INVALID_HANDLE. This occurs because these objects share the same namespace.