Ejemplo n.º 1
0
//static 
bool Timer_os::Init ()
{
    DWORD ThreadId;

    hWinEvent = CreateEvent (0, FALSE, FALSE, 0);
    hTimerThread  = (HANDLE) CreateThread (0, 0, LPTHREAD_START_ROUTINE(TimerThread), 0, 0, &ThreadId);
    WaitForSingleObject (hWinEvent, INFINITE);
    CloseHandle (hWinEvent);
    hWinEvent = 0;
    return true;
}
Ejemplo n.º 2
0
void CreateWorld()
{
	surfaceShader = createShader("Shaders/SurfaceVertexShader.glsl", "Shaders/SurfacePixelShader.glsl", NULL);
	cloudsShader = createShader("Shaders/CloudsVertexShader.glsl", "Shaders/CloudsPixelShader.glsl", NULL);
	
	createCloudsMap();
	createCloudsTexture();
	initRootMapPatch(rootMapPatch, MapMin, MapMax);
	createPatchDisplayList();
	InitializeCriticalSection(&queueCritSect);
	CreateThread(NULL, 0, LPTHREAD_START_ROUTINE(patchQueueThreadProc), NULL, 0, NULL);
}
HANDLE RemoteThreadInjector::CallWithRemoteThread(LPVOID hModule, LPVOID lp_base_address) const
{
	auto hRemoteHandle = CreateRemoteThread(m_hProcess, nullptr, 0, LPTHREAD_START_ROUTINE(hModule), lp_base_address, 0, nullptr);
	auto error = GetLastError();
	if (error == ERROR_ACCESS_DENIED)
	{
		logError(L"Access was denied by process!", error);
	}
	else if (error != 0)
	{
		logError(L"Unknown error during remote thread creation", error);
	}
	return hRemoteHandle;
}
Ejemplo n.º 4
0
static double
prof_native_thread (size_t iteration)
{
#if defined (ACE_HAS_THREADS)  && (defined (ACE_HAS_WTHREADS) || defined (ACE_HAS_STHREADS))
    if (iteration != 0)
    {
        ACE_Profile_Timer ptimer;
        ACE_Profile_Timer::ACE_Elapsed_Time et;
        double time = 0;

        for (size_t i = 0; i < iteration; i++)
        {
            ACE_STOP_SIGN;
            ptimer.start ();
            for (size_t j = 0; j < MULTIPLY_FACTOR; j++)
            {
#if defined (ACE_HAS_WTHREADS)
                if (::CreateThread (NULL,
                                    0,
                                    LPTHREAD_START_ROUTINE (ace_empty),
                                    0,
                                    CREATE_SUSPENDED,
                                    0) == NULL)
#elif defined (ACE_HAS_STHREADS)
                if (::thr_create (NULL,
                                  0,
                                  &ace_empty,
                                  0,
                                  THR_SUSPENDED,
                                  NULL) != 0)
#endif
                    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "CreateThread"), -1);
            }
            ptimer.stop ();
            ptimer.elapsed_time (et);
            time += et.real_time;
        }
        iteration *= MULTIPLY_FACTOR;
        return time / iteration;
    }
    else
        return -1.0;
#else
    ACE_UNUSED_ARG (iteration);
    ACE_ERROR_RETURN ((LM_ERROR, "Testing of native threads is not supported on this platform.\n"), -1);
#endif
}
Ejemplo n.º 5
0
void DBWin::start()
{
	if (!initialized)
	{
		std::cerr << "Not initialized" << std::endl;
		return;
	}

	if (hThread)
	{
		std::cerr << "Thread already running" << std::endl;
		return;
	}

	keepRunning = true;
	hThread = CreateThread(nullptr, 0, LPTHREAD_START_ROUTINE(run), this, 0, nullptr);
}
Ejemplo n.º 6
0
// Main driver function for the server.
int main (int argc, char *argv[]) 
{
	struct sockaddr_in sock_addr;
	// Handle UNIX/Win32 portability.
	#if defined (_WIN32)
		SOCKET acceptor;
		WORD version_requested = MAKEWORD(2,0);
		WSADATA wsa_data;
		int error = WSAStartup(version_requested, &wsa_data);
		if (error != 0) return -1;
	#else
		int acceptor;
	#endif /* _WIN32 */
	// Create a local endpoint of communication.
	acceptor = socket (AF_INET,SOCK_STREAM, 0);
	// Set up the address to become a server.
	memset (&sock_addr, 0, sizeof(sock_addr));
	sock_addr.sin_family = PF_INET;
	sock_addr.sin_port = htons(LOGGING_PORT);
	sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	// Associate address with endpoint.
	bind (acceptor,reinterpret_cast<struct sockaddr *>(&sock_addr), sizeof(sock_addr));
	// Make endpoint listen for connections.
	listen (acceptor, 5);

	// Main server event loop.
	for (;;) {
	// Handle UNIX/Win32 portability.
		#if defined (_WIN32)
			SOCKET h;
			DWORD t_id;
		#else
			int h;
			thread_t t_id;
		#endif /* _WIN32 */
		// Block waiting for clients to connect.
		h = accept (acceptor, 0, 0);
		//Spawn a new thread that runs the <server> entry point.
		#if defined (_WIN32)
			CreateThread (0, 0,LPTHREAD_START_ROUTINE(&logging_handler),reinterpret_cast <void *>(h), 0, &t_id);
		#else
			thr_create(0, 0, logging_handler,reinterpret_cast <void *> (h),THR_DETACHED, &t_id);
		#endif /* _WIN32 */
	}
	return 0;
}
Ejemplo n.º 7
0
void WatchDog::RunWatchDog(bool bNotice)
{
	if (false == m_bOpenWatchDog)
	{//关闭看门狗
		ClosedWatchDog();
		return;
	}

	//看门狗已启动
	if (m_hWatchDog)
	{
		return;
	}

	//启动看门狗
	//第一个接口函数,传递心跳间隔
	if(OpenWatchDog(6))
	{
		//传递服务器所在pc的登陆用户名和密码,为自动重启所用
		//if (!WriteAdminInfoToFileEX(m_chSysName, m_chSysPassWord))
		//{
		//	AfxMessageBox(_T("用户信息保存失败!"), MB_OK | MB_ICONINFORMATION);
		//}

		//创建发送心跳的线程和控制线程退出的事件
		DWORD dwRet;
		m_hCloseWatchDogEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
		m_hWatchDog = CreateThread(NULL,0, LPTHREAD_START_ROUTINE (Thread_WatchDog_HeartBeat), (void*)this,0,&dwRet);


		LOG(LEVEL_INFO, "开启看门狗程序");

		if (m_hWatchDog && bNotice)
		{
			AfxMessageBox(_T("启动看门狗成功!"), MB_ICONINFORMATION);
		}

	}
	else 
	{
		AfxMessageBox(_T("启动看门狗失败!"),MB_ICONSTOP);
	}

}
Ejemplo n.º 8
0
void CPlayer::OpenStream()
{
	m_dwDisplayHour		= 0;
	m_dwDisplayMinute   = 0;
	m_dwDisplaySecond   = 0;
	m_dwTotalFrames     = 0;
	m_bFileEnd          = FALSE;
	HIK_MEDIAINFO		stInfo;
	ZeroMemory(&stInfo,sizeof(HIK_MEDIAINFO));

	m_spStreamParser.reset(CStreamParseFactory::OpenFile(m_strPlayFileName));

	if(m_spStreamParser.get() == NULL)
	{
		MessageBox(NULL, _T("Open file failed"), _T("Error"), MB_OK);
		throw 0;
	}
	m_dwMaxFileSize = m_spStreamParser->GetFileSize();
	if (m_dwMaxFileSize == 0)
	{
		MessageBox(NULL, _T("Open file failed"), _T("Error"), MB_OK);
		throw 0;
	}
	NAME(PlayM4_SetStreamOpenMode)(m_index, STREAME_FILE);
	m_dwHeadSize = NAME(PlayM4_GetFileHeadLength)();
	PBYTE pBuf = NULL;
	TCHAR szError[50];

	pBuf = new BYTE[m_dwHeadSize];
	if(!pBuf)
	{
		MessageBox(NULL, _T("Alloc memory failed"), _T("Error"), MB_OK);
		throw 0;
	}
	DWORD nRealRead = m_spStreamParser->ReadCacheData(pBuf, m_dwHeadSize);
	if(nRealRead != m_dwHeadSize)
	{
		MessageBox(NULL, _T("File is too small"), _T("Error"), MB_OK);
		delete []pBuf;
		pBuf = NULL;
		throw 0;
	}

	unsigned int g_strFileHdr[10] = { 0x484B4834, 0xd6d0b3fe, 0x20040308, 0x0, 0x10011001, 0x00101001, 0x3e80, 0x01200160, 0x1011, 0x4 };

#ifdef SPLIT_INPUT
	if(!NAME(PlayM4_OpenStreamEx)(m_lPort, (BYTE*)&stInfo, m_dwHeadSize, 6*1000*1024))
	{
		_stprintf(szError, _T("Open stream failed(%s)"), MyErrorToString(NAME(PlayM4_GetLastError)(m_lPort)));
		MessageBox(csError);
		delete []pBuf;
		pBuf = NULL;
		throw 0;
	}
	PlayM4_SyncToAudio(m_lPort, FALSE);
#else defined MIX_INPUT	

	if(!NAME(PlayM4_OpenStream)(m_index, pBuf, sizeof(stInfo),  6*1000*1024))
	{
		MessageBox(NULL, _T("Open file failed"), _T("Error"), MB_OK);
		delete []pBuf;
		pBuf = NULL;
		throw 0;
	}
#endif

	delete []pBuf;
	pBuf = NULL;

	DWORD dw;
	m_hThread	  = NULL;
	m_hEventInput = NULL;
	m_hEventKill  = NULL;

	ResizeMonitorWindow();

	m_hThread	  =	CreateThread(NULL,0, LPTHREAD_START_ROUTINE (InputStreamThread),this,0,&dw);
	m_hEventInput =	CreateEvent(NULL,TRUE,FALSE,NULL);
	m_hEventKill  =	CreateEvent(NULL,FALSE,FALSE,NULL);
	if( !(m_hThread&&m_hEventInput&&m_hEventKill) )
	{
		MessageBox(NULL, _T("Create thread failed"), _T("Error"), MB_OK);
		throw 0;
	}
	m_dwMaxFileTime = m_spStreamParser->GetLastFrameTime()-m_spStreamParser->GetFirstFrameTime();
	m_dwStreamCurrentTime = 0;
	if(!m_dwMaxFileTime)
	{
		m_dwMaxFileTime = 1;
	}

	m_dwDisplayHour		= m_dwMaxFileTime/3600;
	m_dwDisplayMinute   = (m_dwMaxFileTime % 3600) / 60;
	m_dwDisplaySecond   = m_dwMaxFileTime % 60;
	m_dwTotalFrames		= m_dwMaxFileTime;

	Play();
}
Ejemplo n.º 9
0
HANDLE RunTranslationThread(HANDLE hFrom, HANDLE hTo) {
	PTRANSLATION_PARAMS params = new TRANSLATION_PARAMS;
	params->hFrom = hFrom;
	params->hTo = hTo;
	return CreateThread(NULL, 0, LPTHREAD_START_ROUTINE(&TranslationThread), params, 0, NULL);
}
Ejemplo n.º 10
0
// ============================================================================ //
// Criação da tread final
// ============================================================================ //
void Dll_Inject(){
	CreateThread(NULL,NULL,LPTHREAD_START_ROUTINE(I_Scan),NULL,0,0);
}