C / C++ / MFC

/* MultipleInstance.h */
 
class MultipleInstance {
 
public:
 
    MultipleInstance();
    ~MultipleInstance();
 
    static bool Active();
 
private:
 
    static bool                 _Active;
 
    static bool                 _Initialized;
    static HANDLE               _Handle;
    static MultipleInstance     *_Instance;
 
};
 
/* MultipleInstance.cpp */
 
static MultipleInstance _MultipleInstance;
 
bool                MultipleInstance::_Active       = false;
 
bool                MultipleInstance::_Initialized  = false;
HANDLE              MultipleInstance::_Handle       = NULL;
MultipleInstance    *MultipleInstance::_Instance    = &_MultipleInstance;
 
MultipleInstance::MultipleInstance()
{
    if ((!_Initialized) && (this == _Instance)) {
 
        // create security descriptor to let all users access the semaphore
 
        SECURITY_DESCRIPTOR security_descriptor = { 0 };
 
        InitializeSecurityDescriptor(&security_descriptor,
                                     SECURITY_DESCRIPTOR_REVISION);
 
        SetSecurityDescriptorDacl(&security_descriptor,TRUE,NULL,FALSE);
 
        // create semaphore
 
        SECURITY_ATTRIBUTES security_attributes = { 0 };
 
        security_attributes.nLength              = sizeof(security_attributes);
        security_attributes.lpSecurityDescriptor = &security_descriptor;
        security_attributes.bInheritHandle       = FALSE;
 
        SetLastError(0);
 
        _Handle = ::CreateSemaphore(&security_attributes,0,1,
                                    _T("Global\\InstanceSemaphore"));
                                    /* change "InstanceSemaphore" to your desired name */
 
        if (GetLastError() == ERROR_ALREADY_EXISTS) {
            _Active = true;
        }
 
        _Initialized = true;
 
    }
}
 
MultipleInstance::~MultipleInstance()
{
    if (_Initialized && (this == _Instance)) {
 
        if (_Handle != INVALID_HANDLE_VALUE) &&
           (_Handle != NULL)) {
 
            CloseHandle(_Handle);
            _Handle = NULL;
 
        }
 
    }
}
 
bool MultipleInstance::Active()
{
    return _Active;
}

<br />
m_pMainWnd->ShowWindow(SW_SHOWMAXIMIZED);<br />
m_pMainWnd->UpdateWindow();<br />

rp_suman wrote:

m_pMainWnd->ShowWindow(SW_SHOWMAXIMIZED);
m_pMainWnd->UpdateWindow();

// Relocations.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include <iostream>
#include <windows.h>
using namespace std;
 
int main(int argc, char* argv[])
{
	// First get the DOS header.
	char *pBase = (char*)GetModuleHandle("kernel32.dll");
	PIMAGE_DOS_HEADER pDOS = (PIMAGE_DOS_HEADER)pBase;
	assert(pDOS->e_magic == IMAGE_DOS_SIGNATURE);
 
	// Get the NT headers.
	PIMAGE_NT_HEADERS pNT = (PIMAGE_NT_HEADERS)(pBase + pDOS->e_lfanew);
	assert(pNT->Signature == IMAGE_NT_SIGNATURE);
 
	// Now get the "optional" header.
	PIMAGE_OPTIONAL_HEADER pOpt = &(IMAGE_OPTIONAL_HEADER)(pNT->OptionalHeader);
	assert(pOpt->Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC);
 
	// Get a pointer to the relocation table and its size.
	PIMAGE_DATA_DIRECTORY pRelocDD = &(pOpt->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC]);
	DWORD SizeOfRelocs = pRelocDD->Size;
	PIMAGE_BASE_RELOCATION pReloc = (PIMAGE_BASE_RELOCATION)(pBase + pRelocDD->VirtualAddress);
 
	for (DWORD ToGo = SizeOfRelocs; ToGo>0; /*Empty*/)
	{
		WORD *pRelocArray = (WORD*)(pReloc + 1);
		DWORD NumRelocs = (pReloc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
 
		for (DWORD i=0; i<NumRelocs; ++i)
		{
			WORD val = pRelocArray[i];
			WORD Type = val >> 12;
			WORD RVA = val & 0x0FFF;
 
			cout << hex << "Type = " << Type << ", Address = " << (DWORD)(pBase + pReloc->VirtualAddress + RVA) << endl;
		}
 
		ToGo -= pReloc->SizeOfBlock;
		pReloc = (PIMAGE_BASE_RELOCATION)((char*)pReloc + pReloc->SizeOfBlock);
	}
 
	return 0;
}