Example #1
0
VOID
AppDrone() {
    ULONG i, j;
    HANDLE outp;
    CHAR outstring[80];

    outp = CreateFile('s');

    RtlFormatString(outstring, 80, "\r\nDrone with PID:%d started\r\n", GetProcessId());
    WriteString(outp, outstring);
    KdPrint("in drone 1");
    //Sleep(DRONE_SLEEP_TIME);
    KdPrint("in drone after sleep");
    RtlFormatString(outstring, 80, "\r\nDrone with PID:%d still alive\r\n", GetProcessId());

    for (i = 0; i < 3; i++) {
        KdPrint("in drone 2");
        WriteString(outp, outstring);
        for(j=0;j<0xFFFFFF;j++);
        //Sleep(DRONE_SLEEP_TIME);
    }
    RtlFormatString(outstring, 80, "\r\nDrone with PID:%d killing my self\r\n", GetProcessId());
    KdPrint("in drone 3");
    WriteString(outp, outstring);
    CloseHandle(outp);
    KillMe();
}
Example #2
0
DWORD CALLBACK CaptureAndSuspendProcess(LPVOID)
{
  ImpersonateAnonymousToken(GetCurrentThread());

  while (NtGetNextProcess(nullptr, MAXIMUM_ALLOWED, 0, 0, &g_hProcess) != 0)
  {
  }
  NTSTATUS status = NtSuspendProcess(g_hProcess);

  printf("Suspended process: %08X %p %d\n", status, g_hProcess, GetProcessId(g_hProcess));
  RevertToSelf();

  SetProcessId(GetProcessId(g_hProcess));
  
  WCHAR cmdline[] = L"notepad.exe";
  STARTUPINFO startInfo = {};
  PROCESS_INFORMATION procInfo = {};
  startInfo.cb = sizeof(startInfo);
  if (CreateProcessWithLogonW(L"user", L"domain", L"password", LOGON_NETCREDENTIALS_ONLY,
    nullptr, cmdline, CREATE_SUSPENDED, nullptr, nullptr, &startInfo, &procInfo))
  {
    printf("Created process %d\n", procInfo.dwProcessId);
  }
  else
  {
    printf("Create error: %d\n", GetLastError());
  }
  TerminateProcess(g_hProcess, 0);
  ExitProcess(0);

  return 0;
}
Example #3
0
void FProcState::Wait()
{
	if (bHasBeenWaitedFor)
	{
		return;	// we could try waitpid() another time, but why
	}

	for(;;)	// infinite loop in case we get EINTR and have to repeat
	{
		siginfo_t SignalInfo;
		if (waitid(P_PID, GetProcessId(), &SignalInfo, WEXITED))
		{
			if (errno != EINTR)
			{
				int ErrNo = errno;
				UE_LOG(LogHAL, Fatal, TEXT("FLinuxPlatformProcess::WaitForProc: waitid for pid %d failed (errno=%d, %s)"), 
					static_cast< int32 >(GetProcessId()), ErrNo, ANSI_TO_TCHAR(strerror(ErrNo)));
				break;	// exit the loop if for some reason Fatal log (above) returns
			}
		}
		else
		{
			check(SignalInfo.si_pid == GetProcessId());

			ReturnCode = (SignalInfo.si_code == CLD_EXITED) ? SignalInfo.si_status : -1;
			bHasBeenWaitedFor = true;
			bIsRunning = false;	// set in advance
			break;
		}
	}
}
Example #4
0
static void
MyCreateProcessCommon(BOOL bRet,
                      DWORD dwCreationFlags,
                      LPPROCESS_INFORMATION lpProcessInformation)
{
    if (!bRet) {
        debugPrintf("inject: warning: failed to create child process\n");
        return;
    }

    DWORD dwLastError = GetLastError();

    if (isDifferentArch(lpProcessInformation->hProcess)) {
        debugPrintf("inject: error: child process %lu has different architecture\n",
                    GetProcessId(lpProcessInformation->hProcess));
    } else {
        char szDllPath[MAX_PATH];
        GetModuleFileNameA(g_hThisModule, szDllPath, sizeof szDllPath);

        if (!injectDll(lpProcessInformation->hProcess, szDllPath)) {
            debugPrintf("inject: warning: failed to inject into child process %lu\n",
                        GetProcessId(lpProcessInformation->hProcess));
        }
    }

    if (!(dwCreationFlags & CREATE_SUSPENDED)) {
        ResumeThread(lpProcessInformation->hThread);
    }

    SetLastError(dwLastError);
}
Example #5
0
DWORD
PsProcessHandleToId(HANDLE ProcessHandle)
{
    HANDLE targetHandle;
    DWORD processId;

    if (ProcessHandle == GetCurrentProcess())
    {
        return GetCurrentProcessId();
    }

    processId = GetProcessId(ProcessHandle);

    if (processId)
    {
        return processId;
    }

    if (!PsCopyHandle(GetCurrentProcess(),
                      ProcessHandle,
                      &targetHandle,
                      PROCESS_QUERY_INFORMATION,
                      FALSE))
    {
        return 0;
    }

    processId = GetProcessId(targetHandle);

    CloseHandle(targetHandle);

    return processId;
}
int main(int argc, char* argv[]) 
{
	int a = fork();
	char *env[] = {"PATH=C:\\TEST", NULL};

	if(a > 0)
	{
		printf("\nParent ProcessID : %d\n",GetProcessId());

		waitpid(a);

		printf("\nAfter Child Process has exited");
			
		sleep(10);
			
		printf("\nParent : After Sleep");
		

	}
	else
	{
		printf("\nChild ProcessID : %d\n",GetProcessId());
		char *inp[] = {"bin/hello","a","b"};

		execvpe(inp[0],inp,env);
	}

	return 0;

}
Example #7
0
bool FProcState::IsRunning()
{
	if (bIsRunning)
	{
		check(!bHasBeenWaitedFor);	// check for the sake of internal consistency

		// check if actually running
		int KillResult = kill(GetProcessId(), 0);	// no actual signal is sent
		check(KillResult != -1 || errno != EINVAL);

		bIsRunning = (KillResult == 0 || (KillResult == -1 && errno == EPERM));

		// additional check if it's a zombie
		if (bIsRunning)
		{
			for(;;)	// infinite loop in case we get EINTR and have to repeat
			{
				siginfo_t SignalInfo;
				SignalInfo.si_pid = 0;	// if remains 0, treat as child was not waitable (i.e. was running)
				if (waitid(P_PID, GetProcessId(), &SignalInfo, WEXITED | WNOHANG | WNOWAIT))
				{
					if (errno != EINTR)
					{
						int ErrNo = errno;
						UE_LOG(LogHAL, Fatal, TEXT("FLinuxPlatformProcess::WaitForProc: waitid for pid %d failed (errno=%d, %s)"), 
							static_cast< int32 >(GetProcessId()), ErrNo, ANSI_TO_TCHAR(strerror(ErrNo)));
						break;	// exit the loop if for some reason Fatal log (above) returns
					}
				}
				else
				{
					bIsRunning = ( SignalInfo.si_pid != GetProcessId() );
					break;
				}
			}
		}

		// If child is a zombie, wait() immediately to free up kernel resources. Higher level code
		// (e.g. shader compiling manager) can hold on to handle of no longer running process for longer,
		// which is a dubious, but valid behavior. We don't want to keep zombie around though.
		if (!bIsRunning)
		{
			UE_LOG(LogHAL, Log, TEXT("Child %d is no more running (zombie), Wait()ing immediately."), GetProcessId() );
			Wait();
		}
	}

	return bIsRunning;
}
Example #8
0
void Log(char* szFormat, ...)
{
	va_list vaArgs;

	va_start(vaArgs, szFormat);
	int len = _vscprintf(szFormat, vaArgs);
	char* szString = new char[len+1];
	vsprintf_s(szString, len+1, szFormat, vaArgs);
	va_end(vaArgs);

	time_t tTime;
	time(&tTime);
	char szTime[128] = "";
	struct tm time;
	localtime_s(&time, &tTime);
	strftime(szTime, sizeof(szTime), "%x %X", &time);

	char path[_MAX_PATH+_MAX_FNAME] = "";
	sprintf_s(path, sizeof(path), "%sd2bs.log", Vars.szPath);

#ifdef DEBUG
	FILE* log = stderr;
#else
	FILE* log = _fsopen(path, "a+", _SH_DENYNO);
#endif
	fprintf(log, "[%s] D2BS %d: %s\n", szTime, GetProcessId(GetCurrentProcess()), szString);
#ifndef DEBUG
	fflush(log);
	fclose(log);
#endif
	delete[] szString;
}
Example #9
0
BOOL MEMINFO_API C_GetProcMemInfo(_In_  DWORD  dwProcId, _Out_  PPROCMEMINFO_C pProcMemInfo){
	HANDLE hProc = NULL;
	MEMORYSTATUSEX status;
	PROCESS_MEMORY_COUNTERS procMemCtr;

	printf("\n\n~~~~ INFORMACAO LOCAL DO PROCESSO ~~~~~");

	status.dwLength = sizeof (status);

	if (hProc = OpenProcess(PROCESS_VM_READ|PROCESS_QUERY_INFORMATION, FALSE, dwProcId) == NULL || !GlobalMemoryStatusEx(&status) ||
		!GetProcessMemoryInfo(hProc, &procMemCtr, sizeof(PROCESS_MEMORY_COUNTERS))){
		printf("ERROR: %s\n", GetLastError());
		return FALSE;
	}

	printf("\nProcess ID = %u", GetProcessId(hProc));
	printf("\nTotal de espaco de enderecamento virtual existente: %llu KiB = %llu MiB", status.ullTotalVirtual / KiloB, status.ullTotalVirtual / MegaB);
	printf("\nTotal de espaco de enderecamento virtual disponivel: %llu KiB = %llu MiB", status.ullAvailVirtual / KiloB, status.ullAvailVirtual / MegaB);
	printf("\nDimensao do Working Set: %u KiB = %.2f MiB", procMemCtr.WorkingSetSize / KiloB, (double)procMemCtr.WorkingSetSize / MegaB);

	// Afectar a struct _out_
	pProcMemInfo->processId = dwProcId;
	pProcMemInfo->workingSetSize = procMemCtr.WorkingSetSize;
	pProcMemInfo->totalVirtualSpace = status.ullTotalVirtual;
	pProcMemInfo->availableVirtualSpace = status.ullAvailVirtual;

	printf("\n\nClique em qualquer tecla para terminar..."); getchar();
	CloseHandle(hProc);
	return TRUE;
}
Example #10
0
int KProcess::getProcessId() {
#ifdef _WIN32
	return GetProcessId(pid);
#else
	return pid;
#endif
}
Example #11
0
File: fork.c Project: n13l/kbuild
int
fork(void)
{
	RTL_USER_PROCESS_INFORMATION info;
	NTSTATUS result;

	if (w32_fork == NULL)
		return -ENOSYS;
	/* lets do this */
	result = w32_fork(RTL_CLONE_FLAGS, NULL, NULL, NULL, &info);
	if (result == CLONE_PARENT) {
		pid_t pid = GetProcessId(info.Process);
		ResumeThread(info.Thread);
		CloseHandle(info.Process);
		CloseHandle(info.Thread);
		return pid;
	} else if (result == CLONE_CHILD) {
		/* fix stdio */
		AllocConsole();
		return 0;
	} else
		return -1;

	return -1;
}
void CdbDumperHelper::moduleLoadHook(const QString &module, HANDLE debuggeeHandle)
{
    if (loadDebug > 1)
        qDebug() << "moduleLoadHook" << module << m_state << debuggeeHandle;
    switch (m_state) {
    case Disabled:
    case Initialized:
        break;
    case NotLoaded:
        // Try an inject load as soon as a Qt lib is loaded.
        // for the thread to finish as this would lock up.
        if (m_tryInjectLoad && module.contains(QLatin1String("Qt"), Qt::CaseInsensitive)) {
            // Also shows up in the log window.
            m_manager->showStatusMessage(msgLoading(m_library, true), messageTimeOut);
            QString errorMessage;
            SharedLibraryInjector sh(GetProcessId(debuggeeHandle));
            if (sh.remoteInject(m_library, false, &errorMessage)) {
                m_state = InjectLoading;
            } else {
                m_state = InjectLoadFailed;
                // Ok, try call loading...
                m_manager->showDebuggerOutput(LogMisc, msgLoadFailed(m_library, true, errorMessage));
            }
        }
        break;
    case InjectLoading:
        // check if gdbmacros.dll loaded
        if (module.contains(QLatin1String(dumperModuleNameC), Qt::CaseInsensitive)) {
            m_state = Loaded;
            m_manager->showDebuggerOutput(LogMisc, msgLoadSucceeded(m_library, true));
        }
        break;
    }
}
Example #13
0
int evalProcesses(HANDLE hProcess)
{
    if (NULL == hProcess)
        return 0;

    unsigned int totalMemUsage = 0;
    DWORD processID = GetProcessId(hProcess);
  
    HANDLE hProcessSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    PROCESSENTRY32 processEntry = { 0 };
    processEntry.dwSize = sizeof(PROCESSENTRY32);

    // Retrieves information about the first process encountered in a system snapshot
    if(Process32First(hProcessSnapshot, &processEntry)) {
        do {
            // if th32processID = processID, we are the parent process!  
            // if th32ParentProcessID = processID, we are a child process!
            if ((processEntry.th32ProcessID == processID) || (processEntry.th32ParentProcessID == processID)) {
                unsigned int procMemUsage = 0;
                // Record parent process memory
                procMemUsage = getMemoryInfo(processEntry.th32ProcessID);
                totalMemUsage += procMemUsage;
            }
          // Retrieves information about the next process recorded in a system snapshot.   
        } while(Process32Next(hProcessSnapshot, &processEntry));
    }

    CloseHandle(hProcessSnapshot);
    return totalMemUsage;
}
bool 
Application_ClientConfigManager::closeProcess(DWORD processId, DWORD* error)
{
	HANDLE hProcess = OpenProcess(PROCESS_TERMINATE,TRUE, processId);
	if(hProcess == NULL)
	{
		*error = GetLastError();
		if(*error == ERROR_INVALID_PARAMETER)
		{
			*error = CAPTURE_PE_PROCESS_ALREADY_TERMINATED;
		}
	} else {
		EnumWindows(Application_ClientConfigManager::EnumWindowsProc, (LPARAM)processId);

		DWORD tempProcessId = GetProcessId(hProcess);
		if(tempProcessId == processId)
		{
			if(!TerminateProcess(hProcess, 0))
			{
				*error = GetLastError();
			} else {
				*error = CAPTURE_PE_PROCESS_TERMINATED_FORCEFULLY;
			}
		} else {
			return true;
		}
	}
	return false;
}
Example #15
0
BOOL AppIsAlreadyRunning()
{
    BOOL bRunning=FALSE;
    CString strAppName;
    strAppName = "ZuneNowPlaying.exe";
    DWORD dwOwnPID = GetProcessId(GetCurrentProcess());
    HANDLE hSnapShot=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
    PROCESSENTRY32* processInfo=new PROCESSENTRY32;
    processInfo->dwSize=sizeof(PROCESSENTRY32);
    int index=0;
    while(Process32Next(hSnapShot,processInfo)!=FALSE)
    {
		CString pName = (LPCWSTR)processInfo->szExeFile;
		if (pName.CompareNoCase(strAppName) == 0)
        {
            if (processInfo->th32ProcessID != dwOwnPID)
            {
                bRunning=TRUE;
                break;
            }
        }
    }
    CloseHandle(hSnapShot);
    delete processInfo;
    return bRunning;
}
Example #16
0
Bool restoreBackandParams(
    void*            self,
    BackendParams    param)
{
    strcpy(DataDir, param->dataDir, MAX_PATH);

    memcpy(ListenSockets, &param->listenSockets, sizeof(socket_type));

    CancelKey   = param->cancelKey;
    ChildSlot   = param->childSlot;

    ProcId      = GetProcessId(GetCurrentProcess());

    StartTime   = param->startTime;
    ReloadTime  = param->reloadTime;

    LoggerFileTime     = param->loggerFileTime;
    RedirectDone       = param->redirectDone;
    maxFileDescriptors = param->maxSafeFileDescriptors;

    memcpy(&logPipe, &param->logPipe, sizeof(logPipe));

    strcpy(ExecPath, param->execPath);

    return True;
}
Example #17
0
DWORD JpfsvGetProcessIdContext(
	__in JPFSV_HANDLE ContextHandle
	)
{
	PJPFSV_CONTEXT Context = ( PJPFSV_CONTEXT ) ContextHandle;

	ASSERT( Context && Context->Signature == JPFSV_CONTEXT_SIGNATURE );
	if ( Context && Context->Signature == JPFSV_CONTEXT_SIGNATURE )
	{
		if ( Context->ProcessHandle == JPFSV_KERNEL_PSEUDO_HANDLE )
		{
			//
			// Kernel context.
			//
			return JPFSV_KERNEL;
		}
		else
		{
			return GetProcessId( Context->ProcessHandle );
		}
	}
	else
	{
		return 0;
	}
}
Example #18
0
bool TerminateIfRunning ( void )
{
    bool bAlreadyRunning = false;
    unsigned int index = 0;

    DWORD dwOwnPID   = GetProcessId ( GetCurrentProcess () );
    HANDLE hSnapShot = CreateToolhelp32Snapshot ( TH32CS_SNAPPROCESS, 0 );

    PROCESSENTRY32* processInfo = new PROCESSENTRY32;
    processInfo->dwSize = sizeof ( PROCESSENTRY32 );

    while ( Process32Next ( hSnapShot, processInfo ) != 0 )
    {
        // Convert WCHAR to const char *
        const char * strFileName = reinterpret_cast < const char * >( processInfo->szExeFile );

        if ( !strcmp ( strFileName, "_TODO_EXE_NAME_.exe" ) )
        {
            if ( processInfo->th32ProcessID != dwOwnPID )
            {
                bAlreadyRunning = true;
                break;
            }
        }
    }

    CloseHandle ( hSnapShot );
    delete processInfo;

    return bAlreadyRunning;
}
Example #19
0
File: log.c Project: mt206/flinux
void log_init_thread()
{
	if (!logger_attached)
		return;
	LPCWSTR pipeName = L"\\\\.\\pipe\\flog_server";
	for (;;)
	{
		hLoggerPipe = CreateFileW(pipeName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
		if (hLoggerPipe == INVALID_HANDLE_VALUE)
		{
			/* Non critical error code, just wait and try connecting again */
			if (GetLastError() != ERROR_PIPE_BUSY || !WaitNamedPipeW(pipeName, NMPWAIT_WAIT_FOREVER))
			{
				logger_attached = 0;
				break;
			}
			continue;
		}
		/* Send initial request */
		struct request request;
		request.magic = PROTOCOL_MAGIC;
		request.version = PROTOCOL_VERSION;
		request.pid = GetProcessId(GetCurrentProcess());
		request.tid = GetThreadId(GetCurrentThread());
		DWORD written;
		if (!WriteFile(hLoggerPipe, &request, sizeof(request), &written, NULL))
		{
			CloseHandle(hLoggerPipe);
			logger_attached = 0;
		}
		break;
	}
}
Example #20
0
void KillProcessByNameExcludingMyself(LPCTSTR lpName)
{
    HANDLE hCurrentProcess;
    DWORD dwCurrentProcess;
    HANDLE hSnapShot;
    PROCESSENTRY32 pEntry;
    BOOL hRes;
    HANDLE hProcess;

    hCurrentProcess = GetCurrentProcess();
    dwCurrentProcess = GetProcessId(hCurrentProcess);

    hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0);
    pEntry.dwSize = sizeof(pEntry);
    hRes = Process32First(hSnapShot, &pEntry);
    while (hRes)
    {
        if (strcmp(pEntry.szExeFile, lpName) == 0 && pEntry.th32ProcessID != dwCurrentProcess)
        {
            hProcess = OpenProcess(PROCESS_TERMINATE, 0,
                (DWORD) pEntry.th32ProcessID);
            if (hProcess != NULL)
            {
                TerminateProcess(hProcess, 9);
                CloseHandle(hProcess);
            }
        }
        hRes = Process32Next(hSnapShot, &pEntry);
    }
    CloseHandle(hSnapShot);
}
Example #21
0
//----------------------------
int main(int argc, char* argv[])
{
	// Declare our dll variable 
    char dll[MAX_PATH]; 

	if ( argc != 3 ) {
		cout << "Usage :" << argv[0] << " <PROCESS NAME> <DLL FULL PATH>" << endl;
		exit(1);
	}
	
    // Get the full path of our .dll 
	GetFullPathName( argv[2] , MAX_PATH, dll , NULL);  
	
	// Get PID of notepad.exe		
	DWORD ID = GetProcessId(argv[1]); 
    
	if (!CreateRemoteThreadInject(ID, dll)) {
		
        //If CreateRemoteThreadInject Returned true 
        cout << "Injection failed!" << endl ; 
        exit(1); 
         

    } else {
		
        //If CreateRemoteThreadInject Returned true 
        cout << "Injection of" << argv[2] << " into " << argv[1]  << " is successful!" << endl; 
        exit(1); 
    
	} 
    
	return 0;
}
Example #22
0
/*
	Unload Dll from process

	RETURN:
		Error code
*/
DWORD CMemDll::Unload()
{
	HANDLE hThread = NULL;
	HMODULE hDll = NULL;

    if(!CMemCore::Instance().m_hProcess)
        return ERROR_INVALID_HANDLE;

	//Search for dll in process
	if((hDll = (HMODULE)GetModuleAddress(GetProcessId(CMemCore::Instance().m_hProcess), TEXT(DLL_NAME))) !=0 )
	{
		hThread = CreateRemoteThread
			(
				CMemCore::Instance().m_hProcess, 
				NULL, 0, 
				(LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandleA("Kernel32.dll"), "FreeLibrary"), 
				(void*)hDll, 
				0, NULL
			);

		if(hThread == NULL)
		{
			MessageBox(NULL, TEXT("Cannot create thread"), TEXT("Error"), MB_ICONERROR);
			return GetLastError();
		}
		//Wait for completion
		WaitForSingleObject(hThread, INFINITE);
		CloseHandle(hThread);
	}

    return ERROR_SUCCESS;
}
HMODULE GetRemoteModuleHandle( char *szModuleName, HANDLE hProcess, bool bUsePath )
{
	HANDLE tlh = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, GetProcessId( hProcess ) );

	MODULEENTRY32 modEntry;
	
	modEntry.dwSize = sizeof( MODULEENTRY32 );

	Module32First( tlh, &modEntry );
	do
	{
		string comp;
		comp.clear();

		if(bUsePath){ comp = modEntry.szExePath; } else { comp = modEntry.szModule; }

		if( !strcmp( szModuleName, comp.c_str() ) )
		{
			CloseHandle( tlh );

			return modEntry.hModule;
		}
	}
	while(Module32Next( tlh, &modEntry ) );

	CloseHandle( tlh );

	return NULL;
}
Example #24
0
void PauseResumeThreadList( bool bResumeThread ) 
{ 
	if (hProcess == NULL)
		return;
	DWORD dwOwnerPID = GetProcessId(hProcess);

	HANDLE hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0); 
	if (hThreadSnap == INVALID_HANDLE_VALUE)
		return; 

	THREADENTRY32 te32;
	ZeroMemory(&te32,sizeof(te32));
	te32.dwSize = sizeof(THREADENTRY32); 

	BOOL MoreThreads = Thread32First(hThreadSnap, &te32);
	while (MoreThreads)
	{
		if (te32.th32OwnerProcessID == dwOwnerPID) 
		{
			HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, te32.th32ThreadID);
			if (bResumeThread)
				ResumeThread(hThread);
			else
				SuspendThread(hThread);
			CloseHandle(hThread);
		} 
		MoreThreads = Thread32Next(hThreadSnap, &te32);
	}
	CloseHandle (hThreadSnap); 
}
Example #25
0
void srand2() {
    unsigned long seed = srand2_mix(
                             clock(),
                             (unsigned long)time(NULL),
                             GetProcessId(GetModuleHandle(NULL)));
    srand(seed);
}
unsigned long ClassSpaceChecker::runProgram(const QString &theUri, const QString &param, bool silentMode, bool waitExit)
{
	QString uri = QDir::toNativeSeparators(theUri);

	std::wstring uriW = uri.toStdWString().c_str();
	std::wstring paramW = param.toStdWString().c_str();

	SHELLEXECUTEINFOW shellExInfo;
	memset(&shellExInfo, 0, sizeof(SHELLEXECUTEINFO));
	shellExInfo.cbSize = sizeof(SHELLEXECUTEINFO);
	shellExInfo.hwnd = NULL;
	shellExInfo.lpVerb = L"open";
	shellExInfo.lpFile = uriW.c_str();
	shellExInfo.lpParameters = paramW.c_str();
	shellExInfo.lpDirectory = NULL;
	shellExInfo.nShow = silentMode ? SW_HIDE : SW_SHOWNORMAL;
	shellExInfo.fMask = SEE_MASK_NOCLOSEPROCESS | SEE_MASK_NO_CONSOLE;
	shellExInfo.hInstApp = NULL;

	ShellExecuteEx(&shellExInfo);

	if(waitExit)
		WaitForSingleObject(shellExInfo.hProcess,INFINITE);

	unsigned long processId = GetProcessId(shellExInfo.hProcess); 


	return processId;
}
Example #27
0
ULONG currentProcessId(IDebugSystemObjects *sysObjects)
{
    ULONG64 handle = 0;
    if (sysObjects->GetCurrentProcessHandle(&handle) == S_OK)
        return GetProcessId((HANDLE)handle);
    return 0;
}
Example #28
0
child::child( HANDLE h ):handle_(h),pid_(0)
{
  pid_ = get_invalidate_pid();
  if(handle_ != INVALID_HANDLE_VALUE)
  {
    pid_ = GetProcessId(handle_);
  }
}
Example #29
0
/**
 * There are a bunch of functions that you expect to return a pid,
 * like Unix.getpid() and Unix.create_process(). However, on
 * Windows, instead of returning the process ID, they return a
 * process handle.
 *
 * Process handles seem act like pointers to a process. You can have
 * more than one handle that points to a single process (unlike
 * pids, where there is a single pid for a process).
 *
 * This isn't a problem normally, since functons like Unix.waitpid()
 * will take the process handle on Windows. But if you want to print
 * or log the pid, then you need to dereference the handle and get
 * the pid. And that's what this function does.
 */
value pid_of_handle(value handle) {
  CAMLparam1(handle);
#ifdef _WIN32
  CAMLreturn(Val_int(GetProcessId((HANDLE)Long_val(handle))));
#else
  CAMLreturn(handle);
#endif
}
Example #30
0
STDMETHODIMP CBProcess::get_ProcessID(LONG* newVal)
{
	DWORD dwRet = GetProcessId(m_hProcess);
	if (!dwRet)
		return HRESULT_FROM_WIN32(GetLastError());
	*newVal = (LONG)dwRet;
	return S_OK;
}