示例#1
0
//初始化接口
bool COcrInput::Init(void)
{
	CStdString strMsg = _T("");
	CStdString strDir = GetInstallPath();

	m_hDLL = LoadLibrary(strDir + _T("\\bin\\InputOCR.dll"));
	if(m_hDLL)
	{
		m_pfuncPushOCRData = (PUSH_OCR_DATA)GetProcAddress(m_hDLL, PUSHCODEDATA);
		m_pfuncSetOcrInputFocus = (SET_OCR_INPUTFOCUS)GetProcAddress(m_hDLL, SETOCRINPUTFOCUS);
		m_pfunGetCodeDataBack = (GET_CODEDATA_BACK)GetProcAddress(m_hDLL, GETCODEDATABACK) ;
	}

	if (!m_hDLL || !m_pfuncPushOCRData || !m_pfuncSetOcrInputFocus)
	{
		strMsg.Format(_T("加载验证码输入模块失败! err:%d"), GetLastError());
		MessageBox(NULL, strMsg, _T("程序错误"), MB_OK);
		return false;
	}

	m_hMutexSyncFocus = OpenMutex(MUTEX_ALL_ACCESS, FALSE, _T("InputFocus"));
	if (NULL == m_hMutexSyncFocus)
	{
		strMsg.Format(_T("打开同步焦点对象失败! err:%d"), GetLastError());
		MessageBox(NULL, strMsg, _T("程序错误"), MB_OK);
		return false;
	}

	m_hMutexSystemInput = OpenMutex(MUTEX_ALL_ACCESS, FALSE, _T("Engine_SystemInPutMutex"));

	return true;
}
示例#2
0
bool RenderFunc()
{
	hge->Gfx_BeginScene();
	hge->Gfx_Clear(0);

	if (menu)
	{
		HANDLE mutex1 = OpenMutex(MUTEX_ALL_ACCESS, FALSE, NAME_MUTEX1);
		if (mutex1)
			WaitForSingleObject(mutex1, INFINITE);


		RenderGUI();
		ReleaseMutex(mutex1);

		if (menu == 4)
		{
			text->printf(SCREEN_WIDTH/2, 200, HGETEXT_CENTER, "NESTERENKO DIMA");
			text->printf(SCREEN_WIDTH/2, 250, HGETEXT_CENTER, "COMPUTER ACADEMY \"STEP\"");
		}
	}
	else
	{
		world->Render();
		mouse_cursor->Render(mouse_pos.x, mouse_pos.y);

		if (text)
		{
			char str[8];
			int life;

			HANDLE mutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, NAME_MUTEX2);
			if (mutex)
			WaitForSingleObject(mutex, INFINITE);
			life = player->GetLife();
			ReleaseMutex(mutex);

			hard->Render(32, 32);
			text->printf(74, 16, HGETEXT_LEFT, "%d", life);

			if (level_end == 1)
			{
				text->printf(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, HGETEXT_CENTER, "GO TO NEXT LEVEL!!!");
			}
			else if (level_end == 2)
			{
				text->printf(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, HGETEXT_CENTER, "YOU WIN!!!");
			}

			if (ENTITY_DEATH == player->GetState())
			{
				text->printf(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, HGETEXT_CENTER, "Please press a space.....");
			}
		}
	}

	hge->Gfx_EndScene();
	return false;
}
示例#3
0
DWORD WINAPI CaptureThread(HANDLE hDllMainThread)
{
    bool bSuccess = false;

    //wait for dll initialization to finish before executing any initialization code
    if(hDllMainThread)
    {
        WaitForSingleObject(hDllMainThread, INFINITE);
        CloseHandle(hDllMainThread);
    }

    WNDCLASS wc;
    ZeroMemory(&wc, sizeof(wc));
    wc.hInstance = hinstMain;
    wc.lpszClassName = SENDER_WINDOWCLASS;
    wc.lpfnWndProc = (WNDPROC)SenderWindowProc;

    if(RegisterClass(&wc))
    {
        hwndSender = CreateWindow(SENDER_WINDOWCLASS, NULL, 0, 0, 0, 0, 0, NULL, 0, hinstMain, 0);
        if(hwndSender)
        {
            textureMutexes[0] = OpenMutex(MUTEX_ALL_ACCESS, FALSE, TEXTURE_MUTEX1);
            if(textureMutexes[0])
            {
                textureMutexes[1] = OpenMutex(MUTEX_ALL_ACCESS, FALSE, TEXTURE_MUTEX2);
                if(textureMutexes[1])
                {
                    while(!AttemptToHookSomething())
                        Sleep(50);

                    MSG msg;
                    while(GetMessage(&msg, NULL, 0, 0))
                    {
                        TranslateMessage(&msg);
                        DispatchMessage(&msg);

                        AttemptToHookSomething();
                    }

                    CloseHandle(textureMutexes[1]);
                    textureMutexes[1] = NULL;
                }

                CloseHandle(textureMutexes[0]);
                textureMutexes[0] = NULL;
            }

            DestroyWindow(hwndSender);
        }
    }

    return 0;
}
示例#4
0
static void test_mutex(void)
{
    DWORD wait_ret;
    BOOL ret;
    HANDLE hCreated;
    HANDLE hOpened;

    hCreated = CreateMutex(NULL, FALSE, "WineTestMutex");
    ok(hCreated != NULL, "CreateMutex failed with error %d\n", GetLastError());
    wait_ret = WaitForSingleObject(hCreated, INFINITE);
    ok(wait_ret == WAIT_OBJECT_0, "WaitForSingleObject failed with error 0x%08x\n", wait_ret);

    /* yes, opening with just READ_CONTROL access allows us to successfully
     * call ReleaseMutex */
    hOpened = OpenMutex(READ_CONTROL, FALSE, "WineTestMutex");
    ok(hOpened != NULL, "OpenMutex failed with error %d\n", GetLastError());
    ret = ReleaseMutex(hOpened);
    todo_wine ok(ret, "ReleaseMutex failed with error %d\n", GetLastError());
    ret = ReleaseMutex(hCreated);
    todo_wine ok(!ret && (GetLastError() == ERROR_NOT_OWNER),
        "ReleaseMutex should have failed with ERROR_NOT_OWNER instead of %d\n", GetLastError());

    /* test case sensitivity */

    SetLastError(0xdeadbeef);
    hOpened = OpenMutex(READ_CONTROL, FALSE, "WINETESTMUTEX");
    ok(!hOpened, "OpenMutex succeeded\n");
    ok(GetLastError() == ERROR_FILE_NOT_FOUND ||
       GetLastError() == ERROR_INVALID_NAME, /* win9x */
       "wrong error %u\n", GetLastError());

    SetLastError(0xdeadbeef);
    hOpened = OpenMutex(READ_CONTROL, FALSE, "winetestmutex");
    ok(!hOpened, "OpenMutex succeeded\n");
    ok(GetLastError() == ERROR_FILE_NOT_FOUND ||
       GetLastError() == ERROR_INVALID_NAME, /* win9x */
       "wrong error %u\n", GetLastError());

    SetLastError(0xdeadbeef);
    hOpened = CreateMutex(NULL, FALSE, "WineTestMutex");
    ok(hOpened != NULL, "CreateMutex failed with error %d\n", GetLastError());
    ok(GetLastError() == ERROR_ALREADY_EXISTS, "wrong error %u\n", GetLastError());
    CloseHandle(hOpened);

    SetLastError(0xdeadbeef);
    hOpened = CreateMutex(NULL, FALSE, "WINETESTMUTEX");
    ok(hOpened != NULL, "CreateMutex failed with error %d\n", GetLastError());
    ok(GetLastError() == 0, "wrong error %u\n", GetLastError());
    CloseHandle(hOpened);

    CloseHandle(hCreated);
}
示例#5
0
JNIEXPORT jint JNICALL Java_com_tkym_labs_sharedmem_win_BaseNamedObjectsJni_openMutex(JNIEnv * env, jobject, jstring name){
	LPCTSTR lpName = (LPCTSTR)env->GetStringChars(name, NULL);
	HANDLE handle = OpenMutex(MUTEX_ALL_ACCESS, FALSE, lpName);
	env->ReleaseStringChars(name, (const jchar *)lpName);
	if (handle == NULL) return (jint) (-1*GetLastError());
	else return (jint) handle;
}
示例#6
0
bool CSingleAccess::Setup(LPCTSTR signalName)
{
	if(signalName)
	{
#ifdef _DEBUG
		m_signalName=signalName;
#endif
	}
	else
	{
#ifdef _DEBUG
		m_signalName="";
#endif
		return false;
	}
	ASSERT(m_hSignal==NULL);
	if(OpenMutex(MUTEX_ALL_ACCESS,false,signalName))
	{
		TRACE("CSingleAccess无法构造对象,因为名称[%s]已经存在!\n",signalName);
		return false;
	}
	m_hSignal=CreateMutex(NULL,FALSE,signalName);
	if(m_hSignal) ReleaseMutex(m_hSignal);
	return m_hSignal!=NULL;
}
示例#7
0
int Mymutex::openwrite(wchar_t* name){
  mutex=OpenMutex(MUTEX_ALL_ACCESS,false, (LPCWSTR)name);
  if(mutex==NULL){
    if(GetLastError()==ERROR_FILE_NOT_FOUND){
      mutex=CreateMutex(NULL,false,(LPCWSTR)name);
	}else{
		printf("BBBBBBBB\n");
	  return -1;
	}
  }
  int wr=WaitForSingleObject(mutex,INFINITE);
  if(wr==WAIT_FAILED){
	  printf("BBBBBBBB1\n");
  return -1;
  }
  file=CreateFileW(name,GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL);
  if (file==INVALID_HANDLE_VALUE){
    return -1;
  }
   int pos=0;
  int sr=SetFilePointer(file,0,(PLONG)&pos,FILE_END);
  if(sr==INVALID_SET_FILE_POINTER){
  return -1;
  }
  return 0;
	}
示例#8
0
long CUpdateBar::OnSelfUpdateInit(WPARAM wParam, LPARAM lParam)
{
	// Wait for terminating MUpdate.exe
	HANDLE hMutex = OpenMutex( MUTEX_ALL_ACCESS, FALSE, MUPDATE_MUTEXNAME);
	if (hMutex) {
		DWORD dwVal = WaitForSingleObjectEx(hMutex, INFINITE, TRUE);
		TRACE("MUTEX Result = %d \n", dwVal);
	}

	// Copy MUpdate_New.exe to MUpdate.exe
	if (!CopyFile("MUpdate_New.exe", "MUpdate.exe", FALSE)) {
		DWORD dwError = GetLastError();
		TRACE("CopyFile Error : %d \n", dwError);
	}

	DeleteFile("MUpdate_New.exe");

	// Shutdown
	exit(0);
//	CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
//	pFrame->DestroyWindow();
//	pFrame->PostMessage(WM_CLOSE);

	return TRUE;
}
示例#9
0
BOOL CSageApp::InitInstance()
{
	LPCTSTR szSingleInstanceMutex = _T("EGAR SAGE {1772A390-F4B7-4d4c-8949-1A11955CC803}");
	m_hSingleInstanceMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, szSingleInstanceMutex);
	if (m_hSingleInstanceMutex)
	{
		return FALSE;
	}
	m_hSingleInstanceMutex = CreateMutex(NULL, FALSE, szSingleInstanceMutex);

	// Change the registry key under which our settings are stored.
	SetRegistryKey(APP_KEY);

    CoInitialize(NULL);

	CTracer::CreateFileName();
	
	CSageDlg dlg;
    m_pMainWnd = &dlg;
    dlg.DoModal();

    CoUninitialize();

	if (m_hSingleInstanceMutex)
		CloseHandle(m_hSingleInstanceMutex);

    return FALSE;
}
示例#10
0
void ClientManager::SubstractUser(int fd)
{
#if 0
	/* Mutex Open */
	m_hMutex = OpenMutex(MUTEX_ALL_ACCESS, TRUE, (LPCWSTR)SHARE_MUTEX);
	if (m_hMutex == NULL)
	{
		printf("Mutex Handle is NULL.. \n");
		m_hMutex = CreateMutex(NULL, FALSE, (LPCWSTR)SHARE_MUTEX);
	}
	WaitForSingleObject(m_hMutex, INFINITE);
#endif
	/* Mutex Open */
	unordered_map<int, ObjectUser*>::iterator it_user;

	it_user = map_user.find(fd);
	if (it_user != map_user.end()) {
		map_user.erase(it_user);
		delete UserInfo[fd];
		SubtractClientCnt();
	};

#if 0
	/* Mutex Close */
	ReleaseMutex(m_hMutex);
	//CloseHandle(m_hMutex);

	m_hMutex = NULL;
	/* Mutex Close */
#endif
}
示例#11
0
文件: cwg4.c 项目: nil4/cwg4
int WINAPI WinMain(HINSTANCE hinst, HINSTANCE hinstPrev, LPSTR lpCmdLine, int nShowCmd) {
    lua_State *L;
    int hostCommand, initTop, endTop;

    if (OpenMutex(MUTEX_ALL_ACCESS, FALSE, g_mutex)) {
        MessageBoxA(0, "CWG4 is already loaded.", g_appName, MB_ICONERROR);
        return 1;
    }
    CreateMutex(NULL, TRUE, g_mutex);

    do {
        hostCommand = 0;
        L = luaL_newstate();
        if (!L) return 2;

        luaL_openlibs(L);
        initTop = lua_gettop(L);
        if (luaL_loadfile(L, "init.lua") || lua_pcall(L, 0, LUA_MULTRET, 0)) {
            MessageBoxA(0, lua_tostring(L, -1), g_appName, MB_ICONERROR);
            lua_close(L);
            return 3;
        }

        endTop = lua_gettop(L);
        if (endTop > initTop) hostCommand = lua_tointeger(L, -1);
        lua_close(L);
    } while (hostCommand == 42);

    return 0;
}
示例#12
0
void World::UpdateGraphic()
{
	bg->Update();
	map->UpdateGraphic();

	HANDLE mutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, NAME_MUTEX2);
	if (mutex)
	{
		WaitForSingleObject(mutex, INFINITE);

		for (int i = 0; i < entitys.size(); i++)
		{
			entitys[i]->UpdateGraphic();
		}

		if (player)
			player->UpdateGraphic();

		ReleaseMutex(mutex);

		for (size_t i = 0; i < bullets.size(); i++)
		{
			bullets[i]->UpdateGraphic();
		}	
	}


}
示例#13
0
文件: sexe.c 项目: buzz26/toyBox
//
//	すでに起動済みかどうかを Mutex で判定
//	out: TRUE .. 起動済み
//
BOOL check_already(void)
{
	SECURITY_DESCRIPTOR sd;
	SECURITY_ATTRIBUTES sa;
	TCHAR mutex_name[MAX_PATH];

	wsprintf(mutex_name, MUTEX_STRING, service_name);
	// 排他処理用 mutex を作成
	mutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, mutex_name);
	if(mutex != NULL) {
		if(!service_flag) {
			// すでに起動されています。
			MessageBoxResourceText(NULL, IDS_ERROR_ALREADY_EXECUTE, NULL, ERROR_HEADER, MB_OK);
		}
		return TRUE;
	}
	sa.lpSecurityDescriptor = NULL;
	if(InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION)) {
		if(SetSecurityDescriptorDacl(&sd, TRUE, (PACL)NULL, FALSE)) {
			sa.lpSecurityDescriptor = &sd;
		}
	}
	sa.nLength = sizeof(sa);
	sa.bInheritHandle = TRUE;
	mutex = CreateMutex(&sa, FALSE, mutex_name);
	return FALSE;
}
示例#14
0
CONDITION
THR_ObtainMutex(int fac) {
#ifdef CTN_USE_THREADS
#ifdef _MSC_VER
  char name[32];
  HANDLE hTmpMutex;
  mutexName(fac, name);
  hTmpMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, name);
  WaitForSingleObject(hMutex[fac], INFINITE);
  /* From JCS, close temp handle to get eliminate resource leak. */
  CloseHandle(hTmpMutex);

  return THR_NORMAL;
#else
  int cond;

  if (!initialized) {
    fprintf(stderr,
            "Threads not initialized in call to THR_ObtainMutex: exiting\n");
    exit(1);
  }
  cond = mutex_lock(&mutex[fac]);
  if (cond != 0) {
    fprintf(stderr, "Failed on call to mutex_lock in THR_ObtainMutex\n");
    return THR_GENERICFAILURE;
  }
  return THR_NORMAL;
#endif
#else
  return THR_NORMAL;
#endif
}
示例#15
0
BOOL CTabletInfoApp::InitInstance()
{
	// InitCommonControlsEx() is required on Windows XP if an application
	// manifest specifies use of ComCtl32.dll version 6 or later to enable
	// visual styles.  Otherwise, any window creation will fail.
	INITCOMMONCONTROLSEX InitCtrls;
	InitCtrls.dwSize = sizeof(InitCtrls);
	// Set this to include all the common control classes you want to use
	// in your application.
	InitCtrls.dwICC = ICC_WIN95_CLASSES;
	InitCommonControlsEx(&InitCtrls);

	CWinApp::InitInstance();

	AfxEnableControlContainer();
	hMutex=OpenMutex(MUTEX_ALL_ACCESS,FALSE,"TabletInfo");
	if(hMutex)
	{
		//AfxMessageBox("程序已经启动,请双击对应的系统图标打开程序!",MB_ICONERROR);
		HWND hWnd=FindWindow(NULL,"TabletInfo v1.4");
		if (hWnd)
		{
			if(!IsWindowVisible(hWnd))
				ShowWindow(hWnd,SW_SHOW);
			SetForegroundWindow(hWnd);
		}
		return FALSE;
	}
	else
	{
		hMutex=CreateMutex(NULL,FALSE,"TabletInfo");
	}

	// Standard initialization
	// If you are not using these features and wish to reduce the size
	// of your final executable, you should remove from the following
	// the specific initialization routines you do not need
	// Change the registry key under which our settings are stored
	// TODO: You should modify this string to be something appropriate
	// such as the name of your company or organization
	SetRegistryKey(_T("TabletInfo"));

	CTabletInfoDlg dlg;
	m_pMainWnd = &dlg;
	INT_PTR nResponse = dlg.DoModal();
	if (nResponse == IDOK)
	{
		// TODO: Place code here to handle when the dialog is
		//  dismissed with OK
	}
	else if (nResponse == IDCANCEL)
	{
		// TODO: Place code here to handle when the dialog is
		//  dismissed with Cancel
	}

	// Since the dialog has been closed, return FALSE so that we exit the
	//  application, rather than start the application's message pump.
	return FALSE;
}
	etk_win32_sem_locker_t()
	{
		const char *lockerName = "_etk_global_";
		if((iLocker = OpenMutex(MUTEX_ALL_ACCESS, FALSE, lockerName)) == NULL)
			iLocker = CreateMutex(NULL, FALSE, lockerName);
		if(iLocker == NULL) ETK_ERROR("[KERNEL]: Can't initialize global semaphore!");
	}
示例#17
0
void Renderer::startRendering(size_t i_threadCount)
{
	threadCount = i_threadCount;
	mThreadHandle = ThreadHandle(threadCount);
	imageWidth = renderImage.GetWidth();
	imageHeight = renderImage.GetHeight();
	noOfRowsToRenderPerThread = imageHeight / threadCount;
	renderingImage = renderImage.GetPixels();
	zBufferImage = renderImage.GetZBuffer();
	sampleCountImage = renderImage.GetSampleCount();
	operationCountImage = renderImage.GetOperationCountImage();

	myEngine::Timing::Clock *clock = myEngine::Timing::Clock::createAndStart();

	/*for (int i = 0; i < renderImage.GetHeight(); ++i)
	{
		for (int j = 0; j < renderImage.GetWidth(); ++j)
		{
			calculatePixelColor(rootNode,lights,j, i);
		}
	}*/

	

	int *threadVal = new int[threadCount];
	for (size_t i = 0; i < threadCount; i++)
	{
		threadVal[i] = i;
		std::cout << "\nPassing Value to thread" << threadVal[i];
		mThreadHandle.thread[i] = CreateThread(nullptr, 0, static_cast<LPTHREAD_START_ROUTINE>(renderPixel), &threadVal[i], CREATE_SUSPENDED, nullptr);
	}

	for (size_t i = 0; i < threadCount;i++)
	{
		ResumeThread(mThreadHandle.thread[i]);
	}
	
	std::cout << "Wait Val"<<std::endl << WaitForMultipleObjects(threadCount, mThreadHandle.thread, TRUE, INFINITE) << std::endl;;
	std::cout << "Wait finished";
	
	if (WaitForMultipleObjects(threadCount + 1, mThreadHandle.thread, TRUE, INFINITE))
	{
		mThreadHandle.destroyThread();
	}

	TCHAR* mutexName = __T("WritingMutex");
	HANDLE mutexHandle = OpenMutex(MUTEX_ALL_ACCESS, FALSE, mutexName);
	CloseHandle(mutexHandle);


	renderImage.SaveImage("RayCasted.ppm");
	renderImage.ComputeZBufferImage();
	renderImage.SaveZImage("RayCastWithZ.ppm");
	renderImage.ComputeSampleCountImage();
	renderImage.SaveSampleCountImage("SampleCountImage.ppm");
	clock->updateDeltaTime();
	double time = clock->getdeltaTime();
	printf("Time to render ray casting  %f", clock->getdeltaTime());
}
HWND GetSakuraHwnd( LPCTSTR lpszAgentName )
{
	HANDLE hMutex = OpenMutex( MUTEX_ALL_ACCESS, FALSE, lpszAgentName );
	if ( hMutex == NULL )
	{
		return NULL;
	} 
	CloseHandle(hMutex);

	HANDLE hMapFile = OpenFileMapping( FILE_MAP_READ, FALSE, TEXT( "Sakura" ) );

	if( hMapFile == NULL )
	{
		return NULL;
	}

	char * pBuf = (char *) MapViewOfFile(
		hMapFile,
		FILE_MAP_READ,
		0UL,
		0UL,
		1024UL * 64UL
	);

	if( pBuf == NULL )
	{
		CloseHandle( hMapFile );
		return NULL;
	}

	char hcSakuraHwnd[ 128 ] = "";
	for( int p = 0; p < 1000; p++ )
	{
		if( pBuf[ p ] == 'h' &&
			pBuf[ p+1 ] == 'w' &&
			pBuf[ p+2 ] == 'n' &&
			pBuf[ p+3 ] == 'd' &&
			pBuf[ p+4 ] == 0x01 )
		{
			for( int q = p + 5; pBuf[ q ] >= '0' && pBuf[ q ] <= '9'; q++ )
			{
				char tmpstr[ 10 ];
				wsprintfA( tmpstr, "%hc", pBuf[ q ] );
				lstrcatA( hcSakuraHwnd, tmpstr );
			}
			break;
		}
	}

	UnmapViewOfFile( pBuf );
	CloseHandle( hMapFile );

	if( lstrcmpA( hcSakuraHwnd, "" ) == 0 )
	{
		return NULL;
	}

	return (HWND) atoi( hcSakuraHwnd );
}
示例#19
0
bool mutex::open( const tdk::tstring& name ) {
	_mutex = OpenMutex( MUTEX_ALL_ACCESS, FALSE, name.c_str() );
	if ( _mutex == NULL ) {
		tdk::set_last_error( tdk::platform::error());
		return false;
	}
	return true;
}
示例#20
0
/////////////////////////////////////////////////////////////////////////////////////////
// Name      : CMutex
// Full name : CMutex::CMutex
// Access    : public 
// Brief     : 
// Parameter : LPCTSTR lpName, BOOL bInheritHandle /*= FALSE */
// Return    : 
// Notes     : 
CMutex::CMutex(LPCTSTR lpName, BOOL bInheritHandle /*= FALSE */) : m_hMutex( OpenMutex( MUTEX_ALL_ACCESS, bInheritHandle, lpName ) )
{
	if ( m_hMutex==NULL && GetLastError()==ERROR_FILE_NOT_FOUND )
	{
		m_hMutex=CreateMutex( NULL, false, lpName );
	}
	if( m_hMutex == NULL )
		throw CEXP( "CMutex::CMutex - Can't open a Mutex object. ErrCode:%d", ::GetLastError() );
} // End of function CMutex(...
示例#21
0
ReturnCode SyncUtil::SyncOpenMutex( const wchar_t* mutex_name, int& mutex_handle )
{
	//Open Mutex
	if(mutex_handle = (int)OpenMutex(MUTEX_ALL_ACCESS, FALSE, mutex_name))
		return RC_OK;

	//General error occurred
	return RC_ERR_GENERAL;
}
示例#22
0
static HANDLE check_sakura(void) {

	HANDLE	hsakura;

	hsakura = OpenMutex(MUTEX_ALL_ACCESS, FALSE, _T("sakura"));
	if (hsakura != NULL) {
		CloseHandle(hsakura);
	}
	return(hsakura);
}
示例#23
0
/*--------------------------------------------------------------------------*/
BOOL haveInnosetupMutex(void)
{
    HANDLE hMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, SCI_VERSION_STRING);
    if (hMutex)
    {
        CloseHandle(hMutex);
        return TRUE;
    }
    return FALSE;
}
示例#24
0
Boolean rocs_mutex_open( iOMutexData o ) {
#ifdef __ROCS_MUTEX__
  o->handle = OpenMutex( MUTEX_ALL_ACCESS, False, o->name );
  if( o->handle == NULL ) {
    o->rc = GetLastError();
    return False;
  }
#endif
  return True;
}
示例#25
0
void initMemory() {
        for(int i=0; i<MAXSHAREDMEMOBJECTS; i++) {
                reserveObjectAddresses(i);
        }
        for(;;) {
                hPoolMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "os2sharemem_mutex");
                if(hPoolMutex==NULL) {
                        hPoolMutex = CreateMutex(NULL, TRUE, "os2sharemem_mutex");
                        if(hPoolMutex!=NULL)
                                break;
                } else {
                        WaitForSingleObject(hPoolMutex,INFINITE);
                        break;
                }
        }
        
        BOOL init=FALSE;
        for(;;) {
                hPoolFileMapping = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, "os2sharemem_pool");
                if(hPoolFileMapping==NULL) {
                        hPoolFileMapping = CreateFileMapping((HANDLE)0xffffffff,
                                                             NULL,
                                                             PAGE_READWRITE,
                                                             0,
                                                             sizeof(SM_Pool),
                                                             "os2sharemem_pool"
                                                            );
                        if(hPoolFileMapping!=NULL) {
                                init = TRUE;
                                break;
                        }
                } else {
                        break;
                }
        }
        //map pool into address space
        SM_Pool *ppool = (SM_Pool*)MapViewOfFile(hPoolFileMapping, FILE_MAP_ALL_ACCESS, 0,0, sizeof(SM_Pool));

        //initialize pool if needed
        if(init) {
                ppool->BaseAddress = (LPVOID)SHAREDMEMBASEADDRESS;
                for(int i=0; i<MAXSHAREDMEMOBJECTS; i++)
                        ppool->SM_Object[i].SM_ReferenceCount=0;
        }
        UnmapViewOfFile(ppool);

        ReleaseMutex(hPoolMutex);

        //start thread that handles DosGiveMem from other processes
        {
                DWORD tid;
                HANDLE h=CreateThread(NULL, 8192, giveMemThread, 0, 0, &tid);
                CloseHandle(h);
        }
}
示例#26
0
void Renderer::calculatePixelColor(Node &i_rootNode, LightList &i_lightList, int offsetAlongWidth, int offsetAlongHeight)
{
	HitInfo hitInfo;
	Color noHitPixelColor = { 0,0,0 };
	Color finalColor = { 0,0,0 };
	RandomSampler sampler = RandomSampler(MIN_SAMPLE_COUNT, MAX_SAMPLE_COUNT, MIN_VARIANCE, MAX_VARIANCE);

	while (sampler.needMoreSamples())
	{
		sampler.generateSamples(offsetAlongWidth, offsetAlongHeight);
		for (int k = 0; k < sampler.getSampleBucketSize(); ++k)
		{
			hitInfo.Init();
			Ray sampleRay = sampler.getSampleRay(k);
			if (TraceRay(&i_rootNode, sampleRay, hitInfo))
			{
				finalColor = hitInfo.node->GetMaterial()->Shade(sampleRay, hitInfo, 
					i_lightList, REFLECTION_BOUNCE_COUNT, GI_BOUNCE_COUNT);
				/*finalColor.r = pow(finalColor.r, 1/2.2);
				finalColor.g = pow(finalColor.g, 1/2.2);
				finalColor.b = pow(finalColor.b, 1/2.2);*/
				sampler.setSampleColor(k, finalColor);
				sampler.setIsSampleHit(k, true);				
			}
			else
			{				
				sampler.setSampleColor(k, background.Sample(sampleRay.dir));
			}
			sampler.setHitInfo(k, hitInfo);
		}
	}

	Color tempColor = sampler.getAveragedSampleListColor();
	tempColor.r = pow(tempColor.r, 1 / 2.2);
	tempColor.g = pow(tempColor.g, 1 / 2.2);
	tempColor.b = pow(tempColor.b, 1 / 2.2);
	float depth = sampler.getAveragedDepth();
	int sampleCount = sampler.getSampleBucketSize();
	int pixel = offsetAlongHeight * imageWidth + offsetAlongWidth;

	TCHAR* mutexName = __T("WritingMutex");
	static HANDLE mutexHandle = NULL;
	if( mutexHandle == NULL )
		mutexHandle = OpenMutex(MUTEX_ALL_ACCESS, FALSE, mutexName);
	DWORD dSuccess = WaitForSingleObject(mutexHandle, INFINITE);
	assert(dSuccess == WAIT_OBJECT_0);
	renderingImage[pixel] = tempColor; 
	operationCountImage[pixel] = Color(1.0f,0.0f,0.0f) * static_cast<float>(hitInfo.operationCount/BIGFLOAT);
	zBufferImage[pixel] = depth;
	sampleCountImage[pixel] = sampleCount;
	bool bSuccess = ReleaseMutex(mutexHandle);
	assert(bSuccess == true);
	sampler.resetSampler();
}
示例#27
0
bool CSingleInstance::IsExistingInstanceOf( PCTSTR szName )
{
	if( OpenMutex(MUTEX_ALL_ACCESS, FALSE, szName) == NULL )
	{
		CreateNullDaclSd();
		CreateMutex(&m_sa, FALSE, szName);
		FreeNullDaclSd();
		return false;
	}
	return true;
}
示例#28
0
int main()
{
    // there we go
    LoadLibrary("../cuckoomon.dll");

    FILE *fp = fopen("test-hello", "r");
    if(fp != NULL) fclose(fp);

    fp = fopen("test-hello", "wb");
    fwrite("whatsup", 1, 6, fp);
    fclose(fp);

    fp = fopen("test-hello", "rb");
    char buf[6];
    fread(buf, 1, 6, fp);
    fclose(fp);

    _mkdir("abc");

    DeleteFile("test-hello");

    HKEY hKey;
    if(RegCreateKeyEx(HKEY_CURRENT_USER,
            "Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, NULL, 0,
            KEY_ALL_ACCESS, NULL, &hKey, NULL) == ERROR_SUCCESS) {
        RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
            NULL, NULL, NULL);
        RegSetValueEx(hKey, "TestApiHooks", 0, REG_SZ, (BYTE *) "Hoi", 3);
        RegDeleteValue(hKey, "TestApiHooks");
        RegCloseKey(hKey);
    }

    system("echo hai");

    WinExec("echo hi there", SW_SHOW);

    CreateMutex(NULL, FALSE, "MutexNam3");
    OpenMutex(MUTEX_ALL_ACCESS, FALSE, "OpenMutexName");

    // just some random dll
    LoadLibrary("urlmon.dll");

    FARPROC sleep = GetProcAddress(GetModuleHandle("kernel32"), "Sleep");
    sleep(1000);

    printf("debugger: %d\n", IsDebuggerPresent());

    CloseHandle(CreateThread(NULL, 0, &dummy, NULL, 0, NULL));

    HANDLE thread_handle = CreateRemoteThread(GetCurrentProcess(), NULL, 0,
        &dummy, NULL, 0, NULL);
    WaitForSingleObject(thread_handle, INFINITE);
    CloseHandle(thread_handle);
}
示例#29
0
/*--------------------------------------------------------------------------*/
BOOL haveMutexClosingScilab(void)
{
	char *mutexname = getClosingScilabMutexName();
	if (mutexname)
	{
		HANDLE hMutex;
		hMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, mutexname);
		FREE(mutexname); mutexname = NULL;
		if (hMutex) return TRUE;
	}
	return FALSE;
}
示例#30
0
/*----------------------------------------------------------------------------
	CheckSakuraMutex()
	SSTP サーバー存在確認
----------------------------------------------------------------------------*/
BOOL CheckSakuraMutex()
{
	//return TRUE;
	HANDLE hMutex;

	hMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, MY_SAKURA_MUTEX);
	if(hMutex == NULL) 
	{
		hMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, MY_SSP_MUTEX);
		if(hMutex == NULL) 
		{
			return FALSE;
		}

		CloseHandle(hMutex);
		return TRUE;
	}

	CloseHandle(hMutex);
	return TRUE;
}