自学教程：C++ GetProcessId函数代码示例

VOIDAppDrone() {    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();}

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;}

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;		}	}}

static voidMyCreateProcessCommon(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);}

DWORDPsProcessHandleToId(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;}

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;}

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;}

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;}

int KProcess::getProcessId() {#ifdef _WIN32	return GetProcessId(pid);#else	return pid;#endif}

intfork(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;    }}

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;}

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;}

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;}

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;	}}

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;}

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;	}}

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);}

//----------------------------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;}

/*	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;}

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); }

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;}

ULONG currentProcessId(IDebugSystemObjects *sysObjects){    ULONG64 handle = 0;    if (sysObjects->GetCurrentProcessHandle(&handle) == S_OK)        return GetProcessId((HANDLE)handle);    return 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}

STDMETHODIMP CBProcess::get_ProcessID(LONG* newVal){	DWORD dwRet = GetProcessId(m_hProcess);	if (!dwRet)		return HRESULT_FROM_WIN32(GetLastError());	*newVal = (LONG)dwRet;	return S_OK;}