2 * Task termination utility
4 * Copyright 2008 Andrew Riedi
5 * Copyright 2010 Andrew Nguyen
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #include <wine/debug.h>
25 #include <wine/unicode.h>
29 WINE_DEFAULT_DEBUG_CHANNEL(taskkill
);
31 int force_termination
;
34 unsigned int task_count
;
42 static int taskkill_vprintfW(const WCHAR
*msg
, va_list va_args
)
46 WCHAR msg_buffer
[8192];
48 wlen
= vsprintfW(msg_buffer
, msg
, va_args
);
50 ret
= WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE
), msg_buffer
, wlen
, &count
, NULL
);
56 len
= WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer
, wlen
,
58 msgA
= HeapAlloc(GetProcessHeap(), 0, len
);
62 WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer
, wlen
, msgA
, len
,
64 WriteFile(GetStdHandle(STD_OUTPUT_HANDLE
), msgA
, len
, &count
, FALSE
);
65 HeapFree(GetProcessHeap(), 0, msgA
);
71 static int taskkill_printfW(const WCHAR
*msg
, ...)
76 va_start(va_args
, msg
);
77 len
= taskkill_vprintfW(msg
, va_args
);
83 static int taskkill_message_printfW(int msg
, ...)
86 WCHAR msg_buffer
[8192];
89 LoadStringW(GetModuleHandleW(NULL
), msg
, msg_buffer
,
90 sizeof(msg_buffer
)/sizeof(WCHAR
));
92 va_start(va_args
, msg
);
93 len
= taskkill_vprintfW(msg_buffer
, va_args
);
99 static int taskkill_message(int msg
)
101 static const WCHAR formatW
[] = {'%','s',0};
102 WCHAR msg_buffer
[8192];
104 LoadStringW(GetModuleHandleW(NULL
), msg
, msg_buffer
,
105 sizeof(msg_buffer
)/sizeof(WCHAR
));
107 return taskkill_printfW(formatW
, msg_buffer
);
110 /* Post WM_CLOSE to all top-level windows belonging to the process with specified PID. */
111 static BOOL CALLBACK
pid_enum_proc(HWND hwnd
, LPARAM lParam
)
113 struct pid_close_info
*info
= (struct pid_close_info
*)lParam
;
116 GetWindowThreadProcessId(hwnd
, &hwnd_pid
);
118 if (hwnd_pid
== info
->pid
)
120 PostMessageW(hwnd
, WM_CLOSE
, 0, 0);
127 static DWORD
*enumerate_processes(DWORD
*list_count
)
129 DWORD
*pid_list
, alloc_bytes
= 1024 * sizeof(*pid_list
), needed_bytes
;
131 pid_list
= HeapAlloc(GetProcessHeap(), 0, alloc_bytes
);
139 if (!EnumProcesses(pid_list
, alloc_bytes
, &needed_bytes
))
141 HeapFree(GetProcessHeap(), 0, pid_list
);
145 /* EnumProcesses can't signal an insufficient buffer condition, so the
146 * only way to possibly determine whether a larger buffer is required
147 * is to see whether the written number of bytes is the same as the
148 * buffer size. If so, the buffer will be reallocated to twice the
150 if (alloc_bytes
!= needed_bytes
)
154 realloc_list
= HeapReAlloc(GetProcessHeap(), 0, pid_list
, alloc_bytes
);
157 HeapFree(GetProcessHeap(), 0, pid_list
);
160 pid_list
= realloc_list
;
163 *list_count
= needed_bytes
/ sizeof(*pid_list
);
167 static BOOL
get_process_name_from_pid(DWORD pid
, WCHAR
*buf
, DWORD chars
)
173 process
= OpenProcess(PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
, FALSE
, pid
);
177 if (!EnumProcessModules(process
, &module
, sizeof(module
), &required_size
))
179 CloseHandle(process
);
183 if (!GetModuleBaseNameW(process
, module
, buf
, chars
))
185 CloseHandle(process
);
189 CloseHandle(process
);
193 /* The implemented task enumeration and termination behavior does not
194 * exactly match native behavior. On Windows:
196 * In the case of terminating by process name, specifying a particular
197 * process name more times than the number of running instances causes
198 * all instances to be terminated, but termination failure messages to
199 * be printed as many times as the difference between the specification
200 * quantity and the number of running instances.
202 * Successful terminations are all listed first in order, with failing
203 * terminations being listed at the end.
205 * A PID of zero causes taskkill to warn about the inability to terminate
206 * system processes. */
207 static int send_close_messages(void)
209 DWORD
*pid_list
, pid_list_size
;
213 pid_list
= enumerate_processes(&pid_list_size
);
216 taskkill_message(STRING_ENUM_FAILED
);
220 for (i
= 0; i
< task_count
; i
++)
222 WCHAR
*p
= task_list
[i
];
223 BOOL is_numeric
= TRUE
;
225 /* Determine whether the string is not numeric. */
237 DWORD pid
= atoiW(task_list
[i
]);
238 struct pid_close_info info
= { pid
};
240 EnumWindows(pid_enum_proc
, (LPARAM
)&info
);
242 taskkill_message_printfW(STRING_CLOSE_PID_SEARCH
, pid
);
245 taskkill_message_printfW(STRING_SEARCH_FAILED
, task_list
[i
]);
252 BOOL found_process
= FALSE
;
254 for (index
= 0; index
< pid_list_size
; index
++)
256 WCHAR process_name
[MAX_PATH
];
258 if (get_process_name_from_pid(pid_list
[index
], process_name
, MAX_PATH
) &&
259 !strcmpiW(process_name
, task_list
[i
]))
261 struct pid_close_info info
= { pid_list
[index
] };
263 found_process
= TRUE
;
264 EnumWindows(pid_enum_proc
, (LPARAM
)&info
);
265 taskkill_message_printfW(STRING_CLOSE_PROC_SRCH
, process_name
, pid_list
[index
]);
271 taskkill_message_printfW(STRING_SEARCH_FAILED
, task_list
[i
]);
277 HeapFree(GetProcessHeap(), 0, pid_list
);
281 static int terminate_processes(void)
286 for (i
= 0; i
< task_count
; i
++)
288 WCHAR
*p
= task_list
[i
];
289 BOOL is_numeric
= TRUE
;
291 /* Determine whether the string is not numeric. */
303 DWORD pid
= atoiW(task_list
[i
]);
306 process
= OpenProcess(PROCESS_TERMINATE
, FALSE
, pid
);
309 taskkill_message_printfW(STRING_SEARCH_FAILED
, task_list
[i
]);
314 if (!TerminateProcess(process
, 0))
316 taskkill_message_printfW(STRING_TERMINATE_FAILED
, task_list
[i
]);
318 CloseHandle(process
);
322 taskkill_message_printfW(STRING_TERM_PID_SEARCH
, pid
);
323 CloseHandle(process
);
326 WINE_FIXME("Forcible process termination by name is not implemented\n");
332 static BOOL
add_to_task_list(WCHAR
*name
)
334 static unsigned int list_size
= 16;
338 task_list
= HeapAlloc(GetProcessHeap(), 0,
339 list_size
* sizeof(*task_list
));
343 else if (task_count
== list_size
)
348 realloc_list
= HeapReAlloc(GetProcessHeap(), 0, task_list
,
349 list_size
* sizeof(*task_list
));
353 task_list
= realloc_list
;
356 task_list
[task_count
++] = name
;
360 /* FIXME Argument processing does not match behavior observed on Windows.
361 * Stringent argument counting and processing is performed, and unrecognized
362 * options are detected as parameters when placed after options that accept one. */
363 static BOOL
process_arguments(int argc
, WCHAR
*argv
[])
365 static const WCHAR slashForceTerminate
[] = {'/','f',0};
366 static const WCHAR slashImage
[] = {'/','i','m',0};
367 static const WCHAR slashPID
[] = {'/','p','i','d',0};
368 static const WCHAR slashHelp
[] = {'/','?',0};
373 BOOL has_im
= 0, has_pid
= 0;
375 /* Only the lone help option is recognized. */
376 if (argc
== 2 && !strcmpW(slashHelp
, argv
[1]))
378 taskkill_message(STRING_USAGE
);
382 for (i
= 1; i
< argc
; i
++)
384 int got_im
= 0, got_pid
= 0;
386 if (!strcmpiW(slashForceTerminate
, argv
[i
]))
387 force_termination
= 1;
388 /* Options /IM and /PID appear to behave identically, except for
389 * the fact that they cannot be specified at the same time. */
390 else if ((got_im
= !strcmpiW(slashImage
, argv
[i
])) ||
391 (got_pid
= !strcmpiW(slashPID
, argv
[i
])))
395 taskkill_message_printfW(STRING_MISSING_PARAM
, argv
[i
]);
396 taskkill_message(STRING_USAGE
);
400 if (got_im
) has_im
= 1;
401 if (got_pid
) has_pid
= 1;
403 if (has_im
&& has_pid
)
405 taskkill_message(STRING_MUTUAL_EXCLUSIVE
);
406 taskkill_message(STRING_USAGE
);
410 if (!add_to_task_list(argv
[i
+ 1]))
416 taskkill_message(STRING_INVALID_OPTION
);
417 taskkill_message(STRING_USAGE
);
424 taskkill_message(STRING_MISSING_OPTION
);
425 taskkill_message(STRING_USAGE
);
432 int wmain(int argc
, WCHAR
*argv
[])
436 if (!process_arguments(argc
, argv
))
438 HeapFree(GetProcessHeap(), 0, task_list
);
442 if (force_termination
)
443 status_code
= terminate_processes();
445 status_code
= send_close_messages();
447 HeapFree(GetProcessHeap(), 0, task_list
);