Ferme explorer.exe

**cmhicham** · 14/07/2003, 04h20

salut, comment je peux faire dans mon programe (builder c++) que l'explorer.exe se ferme

merci

**BACUS** · 14/07/2003, 18h04

Il faut juste que tu saches le nom exacte de l'application que tu veux fermer, et ensuite :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
HANDLE hwd;
hwd = FindWindow(0, "Le nom de l'application ex: Microsoft Explorer");
SendMessage(hwd, WM_CLOSE, 0, 0);

**cmhicham** · 14/07/2003, 23h04

Salut Bacus, j'ai essaye avec le code que tu m a donne mais je n'arrive pas a fermer l'application, peut etre que les funcion du code funcion pas au Windows2000?
je croix que c'est la funcion FindWindow que ne funcione pas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
void __fastcall TForm1::Button3Click(TObject *Sender)
{
HANDLE hwd;
hwd = FindWindow(0, "calc.exe");
// hwd = FindWindow(0, "explorer.exe");
SendMessage(hwd, WM_CLOSE, 0, 0);
}

avec le code suivant si j'arrive a le ferme, mais ce code, ferme tout les Thread de explorer y ceci fais como un refreche de du systeme ce qui fais que quelque code de mon programe laisse de funcione

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
void __fastcall TForm1::Button4Click(TObject *Sender)
{
DWORD dwProcessId;
HANDLE HandleProcess;
 
GetWindowThreadProcessId(hwd,&dwProcessId);//Obtention de l'identifiant du thread (dans la variable dwProcessId) qui a créé la fenêtre. La fenêtre est désignée par son Handle
  if (dwProcessId!=0)
  {
    HandleProcess=OpenProcess(PROCESS_TERMINATE,false,dwProcessId); //Obtention du Handle du process à partir de l'identifiant du thread (dwProcessId)
    TerminateProcess(HandleProcess,0);//Arrêt du process désigné par HandleProcess. Tous ses threads sont également arrétés.
  }
}

**BACUS** · 15/07/2003, 09h48

Dans ton code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
void __fastcall TForm1::Button3Click(TObject *Sender) 
{ 
HANDLE hwd; 
hwd = FindWindow(0, "calc.exe"); 
// hwd = FindWindow(0, "explorer.exe"); 
SendMessage(hwd, WM_CLOSE, 0, 0); 
}

"calc.exe" ou "explorer.exe" ne dois pas être le nom physique de l'application mais le nom qui apparait dans la fenetre lorsque tu l'ouvre.
ex : "calc.exe" serait en realitée "Calculatrice" et pour l'exploreur internet, "explorer.exe" deviens "le nom de la page web - Microsoft Internet Explorer"

Come je suis Español mon français n'est pas très bon et je ne sais pas si je m' expliques bien...

**Bernouille** · 15/07/2003, 11h45

Hello,
Le probleme est que FindWindow utilise exactement ce qui apparait dans la fenetre.
Malheureusement, pour Explorer par exemple, cela peut-etre n'importe quoi puisque le repertoire actuel est affiche.

va voir a l'adresse
http://www.neurophys.wisc.edu/ravi/software/

et Kill process by name.

La fonction Win32 proposee permet de donner le nom de l'exe.

Bonne journee

**BACUS** · 15/07/2003, 12h21

Si tu veux un KILLPROCESS Regarde :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
#include <windows.h>
#include <tlhelp32.h>
#include <iostream.h>
 
#ifdef BORLANDC
  #include <string.h>
  #include <ctype.h>
#endif
 
int KILL_PROC_BY_NAME(const char *);
 
int main(int argc,char *argv[])
{
//  Terminate a running process
    char szName[100]="iexplore.exe";   // Name of process to terminate
	int iRes;
 
	iRes=KILL_PROC_BY_NAME(szName);
 
	cout << "Result code=" << iRes << endl;
	return 0;
}
 
int KILL_PROC_BY_NAME(const char *szToTerminate)
{
	BOOL bResult,bResultm;
	DWORD aiPID[1000],iCb=1000,iNumProc,iV2000=0;
	DWORD iCbneeded,i,iFound=0;
	char szName[MAX_PATH],szToTermUpper[MAX_PATH];
	HANDLE hProc,hSnapShot,hSnapShotm;
	OSVERSIONINFO osvi;
    HINSTANCE hInstLib;
	int iLen,iLenP,indx;
    HMODULE hMod;
	PROCESSENTRY32 procentry;      
	MODULEENTRY32 modentry;
 
	// Transfer Process name into "szToTermUpper" and
	// convert it to upper case
	iLenP=strlen(szToTerminate);
	if(iLenP<1 || iLenP>MAX_PATH) return 632;
	for(indx=0;indx<iLenP;indx++)
		szToTermUpper[indx]=toupper(szToTerminate[indx]);
	szToTermUpper[iLenP]=0;
 
     // PSAPI Function Pointers.
     BOOL (WINAPI *lpfEnumProcesses)( DWORD *, DWORD cb, DWORD * );
     BOOL (WINAPI *lpfEnumProcessModules)( HANDLE, HMODULE *,
        DWORD, LPDWORD );
     DWORD (WINAPI *lpfGetModuleBaseName)( HANDLE, HMODULE,
        LPTSTR, DWORD );
 
      // ToolHelp Function Pointers.
      HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD) ;
      BOOL (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32) ;
      BOOL (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32) ;
      BOOL (WINAPI *lpfModule32First)(HANDLE,LPMODULEENTRY32) ;
      BOOL (WINAPI *lpfModule32Next)(HANDLE,LPMODULEENTRY32) ;
 
	// First check what version of Windows we're in
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    bResult=GetVersionEx(&osvi);
	if(!bResult)     // Unable to identify system version
	    return 606;
 
	// At Present we only support Win/NT/2000/XP or Win/9x/ME
	if((osvi.dwPlatformId != VER_PLATFORM_WIN32_NT) &&
		(osvi.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS))
		return 607;
 
    if(osvi.dwPlatformId==VER_PLATFORM_WIN32_NT)
	{
        // Win/NT or 2000 or XP
 
         // Load library and get the procedures explicitly. We do
         // this so that we don't have to worry about modules using
         // this code failing to load under Windows 9x, because
         // it can't resolve references to the PSAPI.DLL.
         hInstLib = LoadLibraryA("PSAPI.DLL");
         if(hInstLib == NULL)
            return 605;
 
         // Get procedure addresses.
         lpfEnumProcesses = (BOOL(WINAPI *)(DWORD *,DWORD,DWORD*))
            GetProcAddress( hInstLib, "EnumProcesses" ) ;
         lpfEnumProcessModules = (BOOL(WINAPI *)(HANDLE, HMODULE *,
            DWORD, LPDWORD)) GetProcAddress( hInstLib,
            "EnumProcessModules" ) ;
         lpfGetModuleBaseName =(DWORD (WINAPI *)(HANDLE, HMODULE,
            LPTSTR, DWORD )) GetProcAddress( hInstLib,
            "GetModuleBaseNameA" ) ;
 
         if(lpfEnumProcesses == NULL ||
            lpfEnumProcessModules == NULL ||
            lpfGetModuleBaseName == NULL)
            {
               FreeLibrary(hInstLib);
               return 700;
            }
 
		bResult=lpfEnumProcesses(aiPID,iCb,&iCbneeded);
		if(!bResult)
		{
			// Unable to get process list, EnumProcesses failed
            FreeLibrary(hInstLib);
			return 701;
		}
 
		// How many processes are there?
		iNumProc=iCbneeded/sizeof(DWORD);
 
		// Get and match the name of each process
		for(i=0;i<iNumProc;i++)
		{
			// Get the (module) name for this process
 
	        strcpy(szName,"Unknown");
			// First, get a handle to the process
	        hProc=OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ,FALSE,
				aiPID[i]);
	        // Now, get the process name
	        if(hProc)
			{
               if(lpfEnumProcessModules(hProc,&hMod,sizeof(hMod),&iCbneeded) )
			   {
                  iLen=lpfGetModuleBaseName(hProc,hMod,szName,MAX_PATH);
			   }
			}
	        CloseHandle(hProc);
 
            if(strcmp(strupr(szName),szToTermUpper)==0)
 
			{
				// Process found, now terminate it
				iFound=1;
				// First open for termination
				hProc=OpenProcess(PROCESS_TERMINATE,FALSE,aiPID[i]);
				if(hProc)
				{
					if(TerminateProcess(hProc,0))
					{
						// process terminated
						CloseHandle(hProc);
                        FreeLibrary(hInstLib);
						return 0;
					}
					else
					{
						// Unable to terminate process
						CloseHandle(hProc);
                        FreeLibrary(hInstLib);
						return 602;
					}
				}
				else
				{
					// Unable to open process for termination
                    FreeLibrary(hInstLib);
					return 604;
				}
			}
		}
	}
 
	if(osvi.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS)
	{
		// Win/95 or 98 or ME
 
		hInstLib = LoadLibraryA("Kernel32.DLL");
		if( hInstLib == NULL )
			return 702;
 
		// Get procedure addresses.
		// We are linking to these functions of Kernel32
		// explicitly, because otherwise a module using
		// this code would fail to load under Windows NT,
		// which does not have the Toolhelp32
		// functions in the Kernel 32.
		lpfCreateToolhelp32Snapshot=
			(HANDLE(WINAPI *)(DWORD,DWORD))
			GetProcAddress( hInstLib,
			"CreateToolhelp32Snapshot" ) ;
		lpfProcess32First=
			(BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
			GetProcAddress( hInstLib, "Process32First" ) ;
		lpfProcess32Next=
			(BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
			GetProcAddress( hInstLib, "Process32Next" ) ;
		lpfModule32First=
			(BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
			GetProcAddress( hInstLib, "Module32First" ) ;
		lpfModule32Next=
			(BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
			GetProcAddress( hInstLib, "Module32Next" ) ;
		if( lpfProcess32Next == NULL ||
			lpfProcess32First == NULL ||
		    lpfModule32Next == NULL ||
			lpfModule32First == NULL ||
			lpfCreateToolhelp32Snapshot == NULL )
		{
			FreeLibrary(hInstLib);
			return 703;
		}
 
		// The Process32.. and Module32.. routines return names in all uppercase
 
		// Get a handle to a Toolhelp snapshot of all the systems processes.
 
		hSnapShot = lpfCreateToolhelp32Snapshot(
			TH32CS_SNAPPROCESS, 0 ) ;
		if( hSnapShot == INVALID_HANDLE_VALUE )
		{
			FreeLibrary(hInstLib);
			return 704;
		}
 
        // Get the first process' information.
        procentry.dwSize = sizeof(PROCESSENTRY32);
        bResult=lpfProcess32First(hSnapShot,&procentry);
 
        // While there are processes, keep looping and checking.
        while(bResult)
        {
		    // Get a handle to a Toolhelp snapshot of this process.
		    hSnapShotm = lpfCreateToolhelp32Snapshot(
			    TH32CS_SNAPMODULE, procentry.th32ProcessID) ;
		    if( hSnapShotm == INVALID_HANDLE_VALUE )
			{
				CloseHandle(hSnapShot);
			    FreeLibrary(hInstLib);
			    return 704;
			}
			// Get the module list for this process
			modentry.dwSize=sizeof(MODULEENTRY32);
			bResultm=lpfModule32First(hSnapShotm,&modentry);
 
			// While there are modules, keep looping and checking
			while(bResultm)
			{
		        if(strcmp(modentry.szModule,szToTermUpper)==0)
				{
				    // Process found, now terminate it
				    iFound=1;
				    // First open for termination
				    hProc=OpenProcess(PROCESS_TERMINATE,FALSE,procentry.th32ProcessID);
				    if(hProc)
					{
					    if(TerminateProcess(hProc,0))
						{
						    // process terminated
							CloseHandle(hSnapShotm);
							CloseHandle(hSnapShot);
							CloseHandle(hProc);
			                FreeLibrary(hInstLib);
						    return 0;
						}
					    else
						{
						    // Unable to terminate process
							CloseHandle(hSnapShotm);
							CloseHandle(hSnapShot);
							CloseHandle(hProc);
			                FreeLibrary(hInstLib);
						    return 602;
						}
					}
				    else
					{
					    // Unable to open process for termination
						CloseHandle(hSnapShotm);
						CloseHandle(hSnapShot);
			            FreeLibrary(hInstLib);
					    return 604;
					}
				}
				else
				{  // Look for next modules for this process
					modentry.dwSize=sizeof(MODULEENTRY32);
					bResultm=lpfModule32Next(hSnapShotm,&modentry);
				}
			}
 
			//Keep looking
			CloseHandle(hSnapShotm);
            procentry.dwSize = sizeof(PROCESSENTRY32);
            bResult = lpfProcess32Next(hSnapShot,&procentry);
        }
		CloseHandle(hSnapShot);
	}
	if(iFound==0)
	{
		FreeLibrary(hInstLib);
		return 603;
	}
	FreeLibrary(hInstLib);
	return 0;
}

**Bernouille** · 15/07/2003, 12h27

Pour info, c'est ce qu'il y a a l'adresse que j'ai donnee

**cmhicham** · 15/07/2003, 15h53

Salut
on peut fermer l'explorer avec la methode suivant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
String lpClassName = "ExploreWClass";//Class de Explorer
HANDLE hwd;
 
hwd=FindWindow(lpClassName.c_str(),0);//encontrar el explorer
PostMessage(hwd, WM_CLOSE, 0, 0);

ça se vois que PostMessage funcion mais SendMessage no

se code fonction bien

Merci

Ferme explorer.exe

C++Builder

Vue hybride

Discussions similaires

Partager

Partager