C / C++ / MFC

goldenrose9 wrote:

but this code doesn't work at all.

goldenrose9 wrote:

nice joke.... Google. anyways thanx 4 d reply

• Hans suggested you could use the TransparentBlt function, and included a link to the MSDN documentation page to help you get started.
• You responded by asking for a sample, rather than trying to work it out for yourself.
• Hans suggested (quite rightly) that there were lots to be found if you use Google.
• You responded by saying you thought his answer was a joke, and thus not worth consideration.
• Hans explained that people are not going to help you unless you are prepared to at least try and do some of your own work.
• You responded by a childish show of petulance, just because people will not do what you are quite capable of doing for yourself.

missile^ m1;
missile^ m2;
missile^ m3;

m1 = gcnew missile(this);
m2 = gcnew missile(this);
m3 = gcnew missile(this);
etc

// declare a list of missiles
List<Missile> missiles=new List<Missile>();   // a List is like an auto-dimensioning array!

// create missiles and load the list
for(int i=0; i<10; i++) {
    Missile m=new Missile();
    m.Location=new Point(100+33*i, 200*10*i);
    m.SetColor(Color.Yellow);
    missiles.Add(m);
}

// do something to those missiles, one by one, by enumerating them
foreach(Missile m in missiles) {
    if (m.IsHit()) m.SetColor(Color.Green);
}

so0_lanhlung2 wrote:

if(!NtQuerySystemInformation(16,&hInfo,sizeof(hInfo),NULL))

void CShowHandlesOfProc::AddHandlesToList(CListCtrl *m_list,DWORD pid)
{
	int nItem=0;
	NTSTATUS                   status;
    PSYSTEM_HANDLE_INFORMATION handleInfo;
    ULONG                      handleInfoSize = 0x10000;
    HANDLE                     processHandle;
    ULONG                      i;
    
    _NtQuerySystemInformation NtQuerySystemInformation = 
    (_NtQuerySystemInformation)GetLibraryProcAddress("ntdll.dll", "NtQuerySystemInformation");

	_NtDuplicateObject NtDuplicateObject =
    (_NtDuplicateObject)GetLibraryProcAddress("ntdll.dll", "NtDuplicateObject");

	_NtQueryObject NtQueryObject =
    (_NtQueryObject)GetLibraryProcAddress("ntdll.dll", "NtQueryObject");

    if(!(processHandle = OpenProcess(PROCESS_DUP_HANDLE|PROCESS_QUERY_INFORMATION|PROCESS_VM_READ,FALSE,pid))) return;

    handleInfo = (PSYSTEM_HANDLE_INFORMATION)malloc(handleInfoSize);

    while((status = NtQuerySystemInformation(SystemHandleInformation,handleInfo,handleInfoSize,NULL)) == STATUS_INFO_LENGTH_MISMATCH)
    handleInfo = (PSYSTEM_HANDLE_INFORMATION)realloc(handleInfo, handleInfoSize *= 2);

    if(!NT_SUCCESS(status)) return;
    
    for(i = 0; i < handleInfo->HandleCount; i++)
    {
        SYSTEM_HANDLE handle     = handleInfo->Handles[i];
        HANDLE dupHandle         = NULL;
        POBJECT_TYPE_INFORMATION objectTypeInfo;
        PVOID                    objectNameInfo;
        UNICODE_STRING           objectName;
        ULONG                    returnLength;

        if(handle.ProcessId != pid) continue;
        if(!NT_SUCCESS(NtDuplicateObject(processHandle,(HANDLE)handle.Handle,GetCurrentProcess(),&dupHandle,0,0,0))) continue;
        objectTypeInfo = (POBJECT_TYPE_INFORMATION)malloc(0x1000);

        if(!NT_SUCCESS(NtQueryObject(dupHandle,ObjectTypeInformation,objectTypeInfo,0x1000,NULL)))
        {
            CloseHandle(dupHandle);
            continue;
        }

        if((handle.GrantedAccess != 0x0012019f)
        && (handle.GrantedAccess != 0x001a019f)
        && (handle.GrantedAccess != 0x00120189)
        && (handle.GrantedAccess != 0x00100000))
        {
            wprintf(L"%s - 0x%X - ",objectTypeInfo->Name.Buffer, handle.Handle);
            //wprintf(L"0x%X",handle.GrantedAccess);
			CString szType,szHandle,szName;
			szHandle.Format(L"0x%X",handle.Handle);
			m_list->InsertItem(nItem,szHandle);
			nItem++;
            objectNameInfo = malloc(0x1000);
            if(!NT_SUCCESS(NtQueryObject(dupHandle,ObjectNameInformation,objectNameInfo,0x1000,&returnLength)))
            {
                objectNameInfo = realloc(objectNameInfo, returnLength);
                if(!NT_SUCCESS(NtQueryObject(dupHandle,ObjectNameInformation,objectNameInfo,returnLength,NULL)))
                {
                    free(objectTypeInfo);
                    free(objectNameInfo);
                    CloseHandle(dupHandle);
                    continue;
                }
            }
            objectName = *(PUNICODE_STRING)objectNameInfo;

            if(objectName.Length) wprintf(L"%s",objectName.Buffer);
            else wprintf(L"\0");
            
            wprintf(L"\n");
        }
        free(objectTypeInfo);
        free(objectNameInfo);
        CloseHandle(dupHandle);
    }
    free(handleInfo);
    CloseHandle(processHandle);
    return;
}

#define SystemHandleInformation 16
#define ObjectBasicInformation 0
#define ObjectNameInformation 1
#define ObjectTypeInformation 2

typedef ULONG (NTAPI *_NtQuerySystemInformation)(
    ULONG SystemInformationClass,
    PVOID SystemInformation,
    ULONG SystemInformationLength,
    PULONG ReturnLength
    );
typedef ULONG (NTAPI *_NtDuplicateObject)(
    HANDLE SourceProcessHandle,
    HANDLE SourceHandle,
    HANDLE TargetProcessHandle,
    PHANDLE TargetHandle,
    ACCESS_MASK DesiredAccess,
    ULONG Attributes,
    ULONG Options
    );
typedef ULONG (NTAPI *_NtQueryObject)(
    HANDLE ObjectHandle,
    ULONG ObjectInformationClass,
    PVOID ObjectInformation,
    ULONG ObjectInformationLength,
    PULONG ReturnLength
    );

typedef struct _UNICODE_STRING
{
    USHORT Length;
    USHORT MaximumLength;
    PWSTR Buffer;
} UNICODE_STRING, *PUNICODE_STRING;

typedef struct _SYSTEM_HANDLE
{
    ULONG ProcessId;
    BYTE ObjectTypeNumber;
    BYTE Flags;
    USHORT Handle;
    PVOID Object;
    ACCESS_MASK GrantedAccess;
} SYSTEM_HANDLE, *PSYSTEM_HANDLE;

typedef struct _SYSTEM_HANDLE_INFORMATION
{
    ULONG HandleCount;
    SYSTEM_HANDLE Handles[1];
} SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;

typedef enum _POOL_TYPE
{
    NonPagedPool,
    PagedPool,
    NonPagedPoolMustSucceed,
    DontUseThisType,
    NonPagedPoolCacheAligned,
    PagedPoolCacheAligned,
    NonPagedPoolCacheAlignedMustS
} POOL_TYPE, *PPOOL_TYPE;

typedef struct _OBJECT_TYPE_INFORMATION
{
    UNICODE_STRING Name;
    ULONG TotalNumberOfObjects;
    ULONG TotalNumberOfHandles;
    ULONG TotalPagedPoolUsage;
    ULONG TotalNonPagedPoolUsage;
    ULONG TotalNamePoolUsage;
    ULONG TotalHandleTableUsage;
    ULONG HighWaterNumberOfObjects;
    ULONG HighWaterNumberOfHandles;
    ULONG HighWaterPagedPoolUsage;
    ULONG HighWaterNonPagedPoolUsage;
    ULONG HighWaterNamePoolUsage;
    ULONG HighWaterHandleTableUsage;
    ULONG InvalidAttributes;
    GENERIC_MAPPING GenericMapping;
    ULONG ValidAccess;
    BOOLEAN SecurityRequired;
    BOOLEAN MaintainHandleCount;
    USHORT MaintainTypeList;
    POOL_TYPE PoolType;
    ULONG PagedPoolUsage;
    ULONG NonPagedPoolUsage;
} OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;

so0_lanhlung2 wrote:

Access violation reading location 0xbaadf00d.
i