ja ich habe gesucht, aber leider nichts passendes gefunden.

So zu meinem Anliegen:
Ich möchte gerne die Kommandozeile eines anderen Prozesses lesen. Der Process Explorer von Sysinternals macht das so schön
Mit GetCommandLine kriege ich ja nur die des aktuellen Prozesses. Ich habe auch in der MSDN nichts passendes gefunden. Jemand ne Idee?

Kannst du ja bei denen im Forum fragen falls es hier keiner weiß.

Das werde ich machen, danke. Ich warte aber erstmal ab, ob das hier jemand weiß.

Du kannst ja mit einer Dll GetCommandLine in dem anderen Prozeß aufrufen und das dann Ergebnis dann in deinen Prozeß verfrachten.

Mir ist nicht ganz klar wie ich den anderen Prozess dazu bringen soll eine solche Bibliothek aufzurufen. Ich kann den anderen Prozess ja nicht verändern. Wenn ich das könnte würde ich andere Wege gehen. Oder habe ich dich mißverstanden.

ich habe jetzt mal ein bißchen ausprobiert. Leider geht es nicht
Es gibt scheinbar keine error codes != 0 aber der Thread läuft auch nicht los.

void getProcessCommandLine (int processID, char* commandLineBuffer, int bufferSize)
{
	HANDLE pHandle = OpenProcess (
		PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ, TRUE, processID);
	DWORD threadID = 0;	
	HANDLE hThread = CreateRemoteThread (pHandle, NULL, 0, getCommandLineThreadProc, (LPVOID)commandLineBuffer, 0, &threadID);
	if (!hThread)
	{
		MessageBox (NULL, "Thread nicht erzeugt", NULL, 0);
		return;
	}
	WaitForSingleObject (hThread, INFINITE);
}

DWORD WINAPI getCommandLineThreadProc(LPVOID lpParameter)
{	
	lpParameter = (LPVOID)GetCommandLine ();
	return 1;
}

Jemand ne Idee was ich falsch gemacht hab?

Schau mal hier vorbei : http://www.codeproject.com/threads/winspy.asp

# Retrieve a HANDLE to the remote process (OpenProcess).
# Allocate memory for the DLL name in the remote process (VirtualAllocEx).
# Write the DLL name, including full path, to the allocated memory (WriteProcessMemory).
# Map your DLL to the remote process via CreateRemoteThread & LoadLibrary.
# Wait until the remote thread terminates (WaitForSingleObject); this is until the call to LoadLibrary returns. Put another way, the thread will terminate as soon as our DllMain (called with reason DLL_PROCESS_ATTACH) returns.
# Retrieve the exit code of the remote thread (GetExitCodeThread). Note that this is the value returned by LoadLibrary, thus the base address (HMODULE) of our mapped DLL.
# Free the memory allocated in Step #2 (VirtualFreeEx).
# Unload the DLL from the remote process via CreateRemoteThread & FreeLibrary. Pass the HMODULE handle retreived in Step #6 to FreeLibrary (via lpParameter in CreateRemoteThread).
Note: If your injected DLL spawns any new threads, be sure they are all terminated before unloading it.
# Wait until the thread terminates (WaitForSingleObject).

Ich hab hier mal nen Code von mir hochgeladen in dem die ganze RemoteThread-Sache behandelt wird, bei Fragen stehe ich zur Verfügung

http://www.mmsources.de/pub/ProcessCodeInjection.rar

#include <windows.h>

typedef LONG NTSTATUS;
typedef LONG KPRIORITY;
typedef struct _PEB *PPEB;

struct INFOBLOCK
{
    CHAR stuff[68];
    PWCHAR cmdline;
};

struct PEB
{
    CHAR   stuff[16];
    INFOBLOCK *pinfoblock;
};

struct PROCESS_BASIC_INFORMATION {
    NTSTATUS ExitStatus;
    PEB *PebBaseAddress;
    ULONG_PTR AffinityMask;
    KPRIORITY BasePriority;
    ULONG_PTR UniqueProcessId;
    ULONG_PTR InheritedFromUniqueProcessId;
};

enum PROCESSINFOCLASS {
    ProcessBasicInformation,
	// [...]
};

typedef NTSTATUS (NTAPI *PNtQueryInformationProcess) (HANDLE,PROCESSINFOCLASS,PVOID,ULONG,PULONG);

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
{
	DWORD dwPID = 0x8B8; //Hardcoded pid

	HMODULE hmod = LoadLibrary("ntdll.dll");

	PNtQueryInformationProcess pNtQueryInformationProcess = 
		(PNtQueryInformationProcess) GetProcAddress(hmod,"NtQueryInformationProcess");	

	HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS,FALSE,dwPID);

	if (!hProc) {
		MessageBox(NULL,"OpenProcess failed","Error",MB_ICONERROR | MB_OK);
		return -1;
	}

	PROCESS_BASIC_INFORMATION pbi;
	ZeroMemory(&pbi,sizeof(pbi));

	ULONG cbRet = 0;
	NTSTATUS Ret = pNtQueryInformationProcess(hProc,ProcessBasicInformation,(PVOID)&pbi,sizeof(pbi),&cbRet);

	if (Ret!=0) {
		MessageBox(NULL,"NtQueryInformationProcess failed","Error",MB_ICONERROR | MB_OK);
		CloseHandle(hProc);
		return -1;
	}

	PEB peb;
	INFOBLOCK infoblock;
	WCHAR cmdline[256];

	SIZE_T bytesread = 0;

	BOOL bRet = ReadProcessMemory(hProc,pbi.PebBaseAddress,&peb,sizeof(peb),&bytesread);
	bRet = ReadProcessMemory(hProc,peb.pinfoblock,&infoblock,sizeof(infoblock),&bytesread);
	bRet = ReadProcessMemory(hProc,infoblock.cmdline,cmdline,256,&bytesread);

	if (!bRet) {
		MessageBox(NULL,"ReadProcessMemory failed","Error",MB_ICONERROR | MB_OK);
		CloseHandle(hProc);
		return -1;
	}

	CloseHandle(hProc);

	MessageBoxW(NULL,cmdline,L"huhu",MB_OK);

	return 0;
}

aber normalerweise macht man das einfach mit der umleitung von stdin und stdout also standart input und output

wenn jemand nen kleinen code dazu gebrauchen kann schreibt es ich stell dann die funktion hier rein ist zwar nicht fertig aber funktioniert schon halbwegs