PDA

Visualizza la versione completa : [C++] Processi


Vinniec
03-10-2003, 05:33
Ciao a tutti,
Avrei bisogno di accedere ai processi attivi nel sistema (come task manager) per poter eventualmente scegliere quale far capitolare... credo di aver trovato il metodo ma fin ora non sono riuscito a far partire l'applicazione. Guardate qui:
dopo aver dichiarato tagPROCESSENTRY32, MSDN dice di settare il membro dwSize a sizeof(PROCESSENTRY32).
Bene, settando questo membro l'applicazione crasha
(unhandled ex.... access violation)
--- --- ----
a) vi chiedo intanto se questa la strada giusta
b) chiedo se qualcuno di voi ha idea del perch, facendo il debug, l'istruzione bloccante proprio l'assegnazione del membro dwSize. Diversamente, cio non settando la variabile, il programma crasha uguale (proprio come nonna MSDN dice!)
Sar merito del connubio xp+visual c++ 6.0 o (come al solito) ho scritto male il codice? eccolo tuttoooooooo:
HANDLE TSnap32=CreateToolhelp32Snapshot(
TH32CS_SNAPPROCESS,0);
tagPROCESSENTRY32 *PE;
PE->dwSize=sizeof(PROCESSENTRY32);
Process32First(TSnap32,PE);
CString path=PE->szExeFile;
m_list.AddString(path); :dh:
Asp, non ho finito.. se qualcuno dovesse conoscere codice simile per j++ me lo posti (perlomeno mi faccia sapere il package da utilizzare e le funz.)
GRAZIEEEEEEEEEE :D

Shores
09-10-2003, 20:52
Non ho info dirette su quello che stai tentando, ma spesso mi capitato di trovare grossi buchi nella documentazione MS per quello che riguarda le dimensioni delle strutture; di solito una soluzione stupida quella di esagerare, metti il doppio di quel che ti direbbe la documentazione, ovvero il doppio di quello che ti restituisce sizeof(), di solito cos funziona e puoi poi calare fino a scoprire quale il valore giusto...

Ciao!

Vinniec
09-10-2003, 21:19
E' vero, ho notato anch'io metodi in msdn che si tramutano in poderosi crash e, nel mio caso, nell'abbandono della strada principale (ed alle volte + semplice) per viuzze malriuscite che rendono il codice molto debole. Chiss com' la nuova msdn.... :bh:

Andrea Simonassi
11-10-2003, 12:20
Una volta avevamo un sistema Fax che creava dei file word, e per fare questo lanciava Word, ma spesso non riusciva a chiuderlo, allora avevo scritto un progamma che ogni 10 minuti registrava i processi di word attivi, e se al passaggio successivo li trovava ancora vivi, li killava....


Ho un po' riadattato il codice, vedi se pu essere utile, era un programma sviluppato in poche ore, partendo da un esempio su MSDN, per cui non certo perfetto, ma come tutorial pu andare.

tasks.c


#include <windows.h>
#include <psapi.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//return 0:killed, 1: not killed
int Kill(int pID)
{
int ret;
HANDLE hProcess=OpenProcess(PROCESS_ALL_ACCESS,TRUE,pID);

if(hProcess==NULL)
{
return 1;
}

ret = !TerminateProcess(hProcess,0);
CloseHandle(hProcess);
return ret;
}

char * GetProcessName(DWORD processID ,char * szProcessName, DWORD bufsiz)
{

// Get a handle to the process.

HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION |
PROCESS_VM_READ,
0, processID );

szProcessName[0]='\0';

// Get the process name.

if (NULL != hProcess )
{
HMODULE hMod;
DWORD cbNeeded;

if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod),
&cbNeeded) )
{
GetModuleBaseName( hProcess, hMod, szProcessName,
bufsiz );
}
else return NULL;
}
else return NULL;


CloseHandle( hProcess );

return szProcessName;
}



int main(int argc, char**argv)
{

char szProcessName[MAX_PATH];

DWORD aProcesses[1024], cbNeeded, cProcesses;
unsigned int i;


if ( !EnumProcesses( aProcesses, sizeof(aProcesses), &cbNeeded ) )
return 1;

cProcesses = cbNeeded / sizeof(DWORD);

for ( i = 0; i < cProcesses; ++i )
{
GetProcessName(aProcesses[i],szProcessName,MAX_PATH);
printf("%08X %s\n",aProcesses[i], szProcessName);
}

return 0;
}



ricorda di linkare psapi.lib

Vinniec
11-10-2003, 17:21
Grazie tante,
Per ho un problema: psapi.h non lo trova.... nell'msdn non porta un inclusione particolare per l'utilizzo della funzione EnumProcesses, cos quando l'ho compilato, ovviamente, mi ha dato errore poich non conosceva la fnz. Ho provato ad includere "psapi.h" ma non lo trova. Qualcosa mi sfugge. :bh:
Che pensi?

Andrea Simonassi
12-10-2003, 12:06
mi sa che dipende dalla versione di windows, funziona solo per la famiglia NT (quindi non W95, W98, WME, quusti ultimi non hanno un kernel *serio*)

$$$
12-10-2003, 12:24
Requirements
Windows NT/2000/XP/2003: Included in Windows NT 4.0 and later.
Windows 95/98/Me: Unsupported.
Header: Declared in Psapi.h.
Library: Use Psapi.lib.


come ha detto "Andrea Simonassi" :)

$$$
12-10-2003, 12:27
Taking a Snapshot and Viewing Processes

The following example obtains a list of running processes. First, the GetProcessList function takes a snapshot of the currently executing processes in the system using the CreateToolhelp32Snapshot function, then it walks through the list recorded in the snapshot, using the Process32First and Process32Next functions. For each process, the function calls GetProcessModule, which is defined in Traversing the module list.

#include <windows.h>
#include <tlhelp32.h>
#include <stdio.h>

BOOL GetProcessList ()
{
HANDLE hProcessSnap = NULL;
BOOL bRet = FALSE;
PROCESSENTRY32 pe32 = {0};

// Take a snapshot of all processes in the system.

hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

if (hProcessSnap == INVALID_HANDLE_VALUE)
return (FALSE);

// Fill in the size of the structure before using it.

pe32.dwSize = sizeof(PROCESSENTRY32);

// Walk the snapshot of the processes, and for each process,
// display information.

if (Process32First(hProcessSnap, &pe32))
{
DWORD dwPriorityClass;
BOOL bGotModule = FALSE;
MODULEENTRY32 me32 = {0};

do
{
bGotModule = GetProcessModule(pe32.th32ProcessID,
pe32.th32ModuleID, &me32, sizeof(MODULEENTRY32));

if (bGotModule)
{
HANDLE hProcess;

// Get the actual priority class.
hProcess = OpenProcess (PROCESS_ALL_ACCESS,
FALSE, pe32.th32ProcessID);
dwPriorityClass = GetPriorityClass (hProcess);
CloseHandle (hProcess);

// Print the process's information.
printf( "\nPriority Class Base\t%d\n",
pe32.pcPriClassBase);
printf( "PID\t\t\t%d\n", pe32.th32ProcessID);
printf( "Thread Count\t\t%d\n", pe32.cntThreads);
printf( "Module Name\t\t%s\n", me32.szModule);
printf( "Full Path\t\t%s\n\n", me32.szExePath);
}
}
while (Process32Next(hProcessSnap, &pe32));
bRet = TRUE;
}
else
bRet = FALSE; // could not walk the list of processes

// Do not forget to clean up the snapshot object.

CloseHandle (hProcessSnap);
return (bRet);
}


a me funziona perfettamente (non dipende dalla struttura mal-allocata quindi). ho una macchina nt.

Andrea Simonassi
12-10-2003, 13:01
Aspetta, ne hai dimenticato un pezzo...



BOOL GetProcessModule (DWORD dwPID, DWORD dwModuleID,
LPMODULEENTRY32 lpMe32, DWORD cbMe32)
{
BOOL bRet = FALSE;
BOOL bFound = FALSE;
HANDLE hModuleSnap = NULL;

// Take a snapshot of all modules in the specified process.

hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID);
if (hModuleSnap == INVALID_HANDLE_VALUE)
return (FALSE);

// Fill the size of the structure before using it.

lpMe32->dwSize = sizeof(MODULEENTRY32);

// Walk the module list of the process, and find the module of
// interest. Then copy the information to the buffer pointed
// to by lpMe32 so that it can be returned to the caller.

Module32First(hModuleSnap, lpMe32);

CloseHandle (hModuleSnap);

return (1);
}


Per questo non va su NT 4.0, per questo avevo usato l'altro sistema, siccome dovevo farlo girare su NT 4.0

Vinniec
14-10-2003, 04:16
aspettate giovani, altroch! io ho l'xp..e mi sembra si tratti di famiglia NT!
Chiss...probabilmente per l'XP l'unica cosa buona la piattaforma .net ....il vecchio vstudio 6.0 quasi in pensione
Ora vedo come posso fare, gracias

Loading