git.oblomov.eu Git - wine/blob - programs/taskkill/taskkill.c

   1 /*
   2  * Task termination utility
   3  *
   4  * Copyright 2008 Andrew Riedi
   5  * Copyright 2010 Andrew Nguyen
   6  *
   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.
  11  *
  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.
  16  *
  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
  20  */
  21
  22 #include <windows.h>
  23 #include <psapi.h>
  24 #include <wine/debug.h>
  25 #include <wine/unicode.h>
  26
  27 #include "taskkill.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(taskkill);
  30
  31 int force_termination;
  32
  33 WCHAR **task_list;
  34 unsigned int task_count;
  35
  36 struct pid_close_info
  37 {
  38     DWORD pid;
  39     BOOL found;
  40 };
  41
  42 static int taskkill_vprintfW(const WCHAR *msg, va_list va_args)
  43 {
  44     int wlen;
  45     DWORD count, ret;
  46     WCHAR msg_buffer[8192];
  47
  48     wlen = vsprintfW(msg_buffer, msg, va_args);
  49
  50     ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), msg_buffer, wlen, &count, NULL);
  51     if (!ret)
  52     {
  53         DWORD len;
  54         char *msgA;
  55
  56         len = WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen,
  57             NULL, 0, NULL, NULL);
  58         msgA = HeapAlloc(GetProcessHeap(), 0, len);
  59         if (!msgA)
  60             return 0;
  61
  62         WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen, msgA, len,
  63             NULL, NULL);
  64         WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
  65         HeapFree(GetProcessHeap(), 0, msgA);
  66     }
  67
  68     return count;
  69 }
  70
  71 static int taskkill_printfW(const WCHAR *msg, ...)
  72 {
  73     va_list va_args;
  74     int len;
  75
  76     va_start(va_args, msg);
  77     len = taskkill_vprintfW(msg, va_args);
  78     va_end(va_args);
  79
  80     return len;
  81 }
  82
  83 static int taskkill_message_printfW(int msg, ...)
  84 {
  85     va_list va_args;
  86     WCHAR msg_buffer[8192];
  87     int len;
  88
  89     LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer,
  90         sizeof(msg_buffer)/sizeof(WCHAR));
  91
  92     va_start(va_args, msg);
  93     len = taskkill_vprintfW(msg_buffer, va_args);
  94     va_end(va_args);
  95
  96     return len;
  97 }
  98
  99 static int taskkill_message(int msg)
 100 {
 101     static const WCHAR formatW[] = {'%','s',0};
 102     WCHAR msg_buffer[8192];
 103
 104     LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer,
 105         sizeof(msg_buffer)/sizeof(WCHAR));
 106
 107     return taskkill_printfW(formatW, msg_buffer);
 108 }
 109
 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)
 112 {
 113     struct pid_close_info *info = (struct pid_close_info *)lParam;
 114     DWORD hwnd_pid;
 115
 116     GetWindowThreadProcessId(hwnd, &hwnd_pid);
 117
 118     if (hwnd_pid == info->pid)
 119     {
 120         PostMessageW(hwnd, WM_CLOSE, 0, 0);
 121         info->found = TRUE;
 122     }
 123
 124     return TRUE;
 125 }
 126
 127 static DWORD *enumerate_processes(DWORD *list_count)
 128 {
 129     DWORD *pid_list, alloc_bytes = 1024 * sizeof(*pid_list), needed_bytes;
 130
 131     pid_list = HeapAlloc(GetProcessHeap(), 0, alloc_bytes);
 132     if (!pid_list)
 133         return NULL;
 134
 135     for (;;)
 136     {
 137         DWORD *realloc_list;
 138
 139         if (!EnumProcesses(pid_list, alloc_bytes, &needed_bytes))
 140         {
 141             HeapFree(GetProcessHeap(), 0, pid_list);
 142             return NULL;
 143         }
 144
 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
 149          * size. */
 150         if (alloc_bytes != needed_bytes)
 151             break;
 152
 153         alloc_bytes *= 2;
 154         realloc_list = HeapReAlloc(GetProcessHeap(), 0, pid_list, alloc_bytes);
 155         if (!realloc_list)
 156         {
 157             HeapFree(GetProcessHeap(), 0, pid_list);
 158             return NULL;
 159         }
 160         pid_list = realloc_list;
 161     }
 162
 163     *list_count = needed_bytes / sizeof(*pid_list);
 164     return pid_list;
 165 }
 166
 167 static BOOL get_process_name_from_pid(DWORD pid, WCHAR *buf, DWORD chars)
 168 {
 169     HANDLE process;
 170     HMODULE module;
 171     DWORD required_size;
 172
 173     process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
 174     if (!process)
 175         return FALSE;
 176
 177     if (!EnumProcessModules(process, &module, sizeof(module), &required_size))
 178     {
 179         CloseHandle(process);
 180         return FALSE;
 181     }
 182
 183     if (!GetModuleBaseNameW(process, module, buf, chars))
 184     {
 185         CloseHandle(process);
 186         return FALSE;
 187     }
 188
 189     CloseHandle(process);
 190     return TRUE;
 191 }
 192
 193 /* The implemented task enumeration and termination behavior does not
 194  * exactly match native behavior. On Windows:
 195  *
 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.
 201  *
 202  * Successful terminations are all listed first in order, with failing
 203  * terminations being listed at the end.
 204  *
 205  * A PID of zero causes taskkill to warn about the inability to terminate
 206  * system processes. */
 207 static int send_close_messages(void)
 208 {
 209     DWORD *pid_list, pid_list_size;
 210     unsigned int i;
 211     int status_code = 0;
 212
 213     pid_list = enumerate_processes(&pid_list_size);
 214     if (!pid_list)
 215     {
 216         taskkill_message(STRING_ENUM_FAILED);
 217         return 1;
 218     }
 219
 220     for (i = 0; i < task_count; i++)
 221     {
 222         WCHAR *p = task_list[i];
 223         BOOL is_numeric = TRUE;
 224
 225         /* Determine whether the string is not numeric. */
 226         while (*p)
 227         {
 228             if (!isdigitW(*p++))
 229             {
 230                 is_numeric = FALSE;
 231                 break;
 232             }
 233         }
 234
 235         if (is_numeric)
 236         {
 237             DWORD pid = atoiW(task_list[i]);
 238             struct pid_close_info info = { pid };
 239
 240             EnumWindows(pid_enum_proc, (LPARAM)&info);
 241             if (info.found)
 242                 taskkill_message_printfW(STRING_CLOSE_PID_SEARCH, pid);
 243             else
 244             {
 245                 taskkill_message_printfW(STRING_SEARCH_FAILED, task_list[i]);
 246                 status_code = 128;
 247             }
 248         }
 249         else
 250         {
 251             DWORD index;
 252             BOOL found_process = FALSE;
 253
 254             for (index = 0; index < pid_list_size; index++)
 255             {
 256                 WCHAR process_name[MAX_PATH];
 257
 258                 if (get_process_name_from_pid(pid_list[index], process_name, MAX_PATH) &&
 259                     !strcmpiW(process_name, task_list[i]))
 260                 {
 261                     struct pid_close_info info = { pid_list[index] };
 262
 263                     found_process = TRUE;
 264                     EnumWindows(pid_enum_proc, (LPARAM)&info);
 265                     taskkill_message_printfW(STRING_CLOSE_PROC_SRCH, process_name, pid_list[index]);
 266                 }
 267             }
 268
 269             if (!found_process)
 270             {
 271                 taskkill_message_printfW(STRING_SEARCH_FAILED, task_list[i]);
 272                 status_code = 128;
 273             }
 274         }
 275     }
 276
 277     HeapFree(GetProcessHeap(), 0, pid_list);
 278     return status_code;
 279 }
 280
 281 static int terminate_processes(void)
 282 {
 283     unsigned int i;
 284     int status_code = 0;
 285
 286     for (i = 0; i < task_count; i++)
 287     {
 288         WCHAR *p = task_list[i];
 289         BOOL is_numeric = TRUE;
 290
 291         /* Determine whether the string is not numeric. */
 292         while (*p)
 293         {
 294             if (!isdigitW(*p++))
 295             {
 296                 is_numeric = FALSE;
 297                 break;
 298             }
 299         }
 300
 301         if (is_numeric)
 302         {
 303             DWORD pid = atoiW(task_list[i]);
 304             HANDLE process;
 305
 306             process = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
 307             if (!process)
 308             {
 309                 taskkill_message_printfW(STRING_SEARCH_FAILED, task_list[i]);
 310                 status_code = 128;
 311                 continue;
 312             }
 313
 314             if (!TerminateProcess(process, 0))
 315             {
 316                 taskkill_message_printfW(STRING_TERMINATE_FAILED, task_list[i]);
 317                 status_code = 1;
 318                 CloseHandle(process);
 319                 continue;
 320             }
 321
 322             taskkill_message_printfW(STRING_TERM_PID_SEARCH, pid);
 323             CloseHandle(process);
 324         }
 325         else
 326             WINE_FIXME("Forcible process termination by name is not implemented\n");
 327     }
 328
 329     return status_code;
 330 }
 331
 332 static BOOL add_to_task_list(WCHAR *name)
 333 {
 334     static unsigned int list_size = 16;
 335
 336     if (!task_list)
 337     {
 338         task_list = HeapAlloc(GetProcessHeap(), 0,
 339                                    list_size * sizeof(*task_list));
 340         if (!task_list)
 341             return FALSE;
 342     }
 343     else if (task_count == list_size)
 344     {
 345         void *realloc_list;
 346
 347         list_size *= 2;
 348         realloc_list = HeapReAlloc(GetProcessHeap(), 0, task_list,
 349                                    list_size * sizeof(*task_list));
 350         if (!realloc_list)
 351             return FALSE;
 352
 353         task_list = realloc_list;
 354     }
 355
 356     task_list[task_count++] = name;
 357     return TRUE;
 358 }
 359
 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[])
 364 {
 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};
 369
 370     if (argc > 1)
 371     {
 372         int i;
 373         BOOL has_im = 0, has_pid = 0;
 374
 375         /* Only the lone help option is recognized. */
 376         if (argc == 2 && !strcmpW(slashHelp, argv[1]))
 377         {
 378             taskkill_message(STRING_USAGE);
 379             exit(0);
 380         }
 381
 382         for (i = 1; i < argc; i++)
 383         {
 384             int got_im = 0, got_pid = 0;
 385
 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])))
 392             {
 393                 if (!argv[i + 1])
 394                 {
 395                     taskkill_message_printfW(STRING_MISSING_PARAM, argv[i]);
 396                     taskkill_message(STRING_USAGE);
 397                     return FALSE;
 398                 }
 399
 400                 if (got_im) has_im = 1;
 401                 if (got_pid) has_pid = 1;
 402
 403                 if (has_im && has_pid)
 404                 {
 405                     taskkill_message(STRING_MUTUAL_EXCLUSIVE);
 406                     taskkill_message(STRING_USAGE);
 407                     return FALSE;
 408                 }
 409
 410                 if (!add_to_task_list(argv[i + 1]))
 411                     return FALSE;
 412                 i++;
 413             }
 414             else
 415             {
 416                 taskkill_message(STRING_INVALID_OPTION);
 417                 taskkill_message(STRING_USAGE);
 418                 return FALSE;
 419             }
 420         }
 421     }
 422     else
 423     {
 424         taskkill_message(STRING_MISSING_OPTION);
 425         taskkill_message(STRING_USAGE);
 426         return FALSE;
 427     }
 428
 429     return TRUE;
 430 }
 431
 432 int wmain(int argc, WCHAR *argv[])
 433 {
 434     int status_code = 0;
 435
 436     if (!process_arguments(argc, argv))
 437     {
 438         HeapFree(GetProcessHeap(), 0, task_list);
 439         return 1;
 440     }
 441
 442     if (force_termination)
 443         status_code = terminate_processes();
 444     else
 445         status_code = send_close_messages();
 446
 447     HeapFree(GetProcessHeap(), 0, task_list);
 448     return status_code;
 449 }