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 <stdlib.h>
  23 #include <windows.h>
  24 #include <psapi.h>
  25 #include <wine/debug.h>
  26
  27 #include "taskkill.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(taskkill);
  30
  31 static BOOL force_termination = FALSE;
  32
  33 static WCHAR **task_list;
  34 static 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, __ms_va_list va_args)
  43 {
  44     int wlen;
  45     DWORD count, ret;
  46     WCHAR msg_buffer[8192];
  47
  48     wlen = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, msg, 0, 0, msg_buffer,
  49                           ARRAY_SIZE(msg_buffer), &va_args);
  50
  51     ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), msg_buffer, wlen, &count, NULL);
  52     if (!ret)
  53     {
  54         DWORD len;
  55         char *msgA;
  56
  57         /* On Windows WriteConsoleW() fails if the output is redirected. So fall
  58          * back to WriteFile(), assuming the console encoding is still the right
  59          * one in that case.
  60          */
  61         len = WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen,
  62             NULL, 0, NULL, NULL);
  63         msgA = HeapAlloc(GetProcessHeap(), 0, len);
  64         if (!msgA)
  65             return 0;
  66
  67         WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen, msgA, len,
  68             NULL, NULL);
  69         WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
  70         HeapFree(GetProcessHeap(), 0, msgA);
  71     }
  72
  73     return count;
  74 }
  75
  76 static int WINAPIV taskkill_printfW(const WCHAR *msg, ...)
  77 {
  78     __ms_va_list va_args;
  79     int len;
  80
  81     __ms_va_start(va_args, msg);
  82     len = taskkill_vprintfW(msg, va_args);
  83     __ms_va_end(va_args);
  84
  85     return len;
  86 }
  87
  88 static int WINAPIV taskkill_message_printfW(int msg, ...)
  89 {
  90     __ms_va_list va_args;
  91     WCHAR msg_buffer[8192];
  92     int len;
  93
  94     LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer, ARRAY_SIZE(msg_buffer));
  95
  96     __ms_va_start(va_args, msg);
  97     len = taskkill_vprintfW(msg_buffer, va_args);
  98     __ms_va_end(va_args);
  99
 100     return len;
 101 }
 102
 103 static int taskkill_message(int msg)
 104 {
 105     static const WCHAR formatW[] = {'%','1',0};
 106     WCHAR msg_buffer[8192];
 107
 108     LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer, ARRAY_SIZE(msg_buffer));
 109
 110     return taskkill_printfW(formatW, msg_buffer);
 111 }
 112
 113 /* Post WM_CLOSE to all top-level windows belonging to the process with specified PID. */
 114 static BOOL CALLBACK pid_enum_proc(HWND hwnd, LPARAM lParam)
 115 {
 116     struct pid_close_info *info = (struct pid_close_info *)lParam;
 117     DWORD hwnd_pid;
 118
 119     GetWindowThreadProcessId(hwnd, &hwnd_pid);
 120
 121     if (hwnd_pid == info->pid)
 122     {
 123         PostMessageW(hwnd, WM_CLOSE, 0, 0);
 124         info->found = TRUE;
 125     }
 126
 127     return TRUE;
 128 }
 129
 130 static DWORD *enumerate_processes(DWORD *list_count)
 131 {
 132     DWORD *pid_list, alloc_bytes = 1024 * sizeof(*pid_list), needed_bytes;
 133
 134     pid_list = HeapAlloc(GetProcessHeap(), 0, alloc_bytes);
 135     if (!pid_list)
 136         return NULL;
 137
 138     for (;;)
 139     {
 140         DWORD *realloc_list;
 141
 142         if (!EnumProcesses(pid_list, alloc_bytes, &needed_bytes))
 143         {
 144             HeapFree(GetProcessHeap(), 0, pid_list);
 145             return NULL;
 146         }
 147
 148         /* EnumProcesses can't signal an insufficient buffer condition, so the
 149          * only way to possibly determine whether a larger buffer is required
 150          * is to see whether the written number of bytes is the same as the
 151          * buffer size. If so, the buffer will be reallocated to twice the
 152          * size. */
 153         if (alloc_bytes != needed_bytes)
 154             break;
 155
 156         alloc_bytes *= 2;
 157         realloc_list = HeapReAlloc(GetProcessHeap(), 0, pid_list, alloc_bytes);
 158         if (!realloc_list)
 159         {
 160             HeapFree(GetProcessHeap(), 0, pid_list);
 161             return NULL;
 162         }
 163         pid_list = realloc_list;
 164     }
 165
 166     *list_count = needed_bytes / sizeof(*pid_list);
 167     return pid_list;
 168 }
 169
 170 static BOOL get_process_name_from_pid(DWORD pid, WCHAR *buf, DWORD chars)
 171 {
 172     HANDLE process;
 173     HMODULE module;
 174     DWORD required_size;
 175
 176     process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
 177     if (!process)
 178         return FALSE;
 179
 180     if (!EnumProcessModules(process, &module, sizeof(module), &required_size))
 181     {
 182         CloseHandle(process);
 183         return FALSE;
 184     }
 185
 186     if (!GetModuleBaseNameW(process, module, buf, chars))
 187     {
 188         CloseHandle(process);
 189         return FALSE;
 190     }
 191
 192     CloseHandle(process);
 193     return TRUE;
 194 }
 195
 196 /* The implemented task enumeration and termination behavior does not
 197  * exactly match native behavior. On Windows:
 198  *
 199  * In the case of terminating by process name, specifying a particular
 200  * process name more times than the number of running instances causes
 201  * all instances to be terminated, but termination failure messages to
 202  * be printed as many times as the difference between the specification
 203  * quantity and the number of running instances.
 204  *
 205  * Successful terminations are all listed first in order, with failing
 206  * terminations being listed at the end.
 207  *
 208  * A PID of zero causes taskkill to warn about the inability to terminate
 209  * system processes. */
 210 static int send_close_messages(void)
 211 {
 212     DWORD *pid_list, pid_list_size;
 213     DWORD self_pid = GetCurrentProcessId();
 214     unsigned int i;
 215     int status_code = 0;
 216
 217     pid_list = enumerate_processes(&pid_list_size);
 218     if (!pid_list)
 219     {
 220         taskkill_message(STRING_ENUM_FAILED);
 221         return 1;
 222     }
 223
 224     for (i = 0; i < task_count; i++)
 225     {
 226         WCHAR *p = task_list[i];
 227         BOOL is_numeric = TRUE;
 228
 229         /* Determine whether the string is not numeric. */
 230         while (*p)
 231         {
 232             if (!iswdigit(*p++))
 233             {
 234                 is_numeric = FALSE;
 235                 break;
 236             }
 237         }
 238
 239         if (is_numeric)
 240         {
 241             DWORD pid = wcstol(task_list[i], NULL, 10);
 242             struct pid_close_info info = { pid };
 243
 244             if (pid == self_pid)
 245             {
 246                 taskkill_message(STRING_SELF_TERMINATION);
 247                 status_code = 1;
 248                 continue;
 249             }
 250
 251             EnumWindows(pid_enum_proc, (LPARAM)&info);
 252             if (info.found)
 253                 taskkill_message_printfW(STRING_CLOSE_PID_SEARCH, pid);
 254             else
 255             {
 256                 taskkill_message_printfW(STRING_SEARCH_FAILED, task_list[i]);
 257                 status_code = 128;
 258             }
 259         }
 260         else
 261         {
 262             DWORD index;
 263             BOOL found_process = FALSE;
 264
 265             for (index = 0; index < pid_list_size; index++)
 266             {
 267                 WCHAR process_name[MAX_PATH];
 268
 269                 if (get_process_name_from_pid(pid_list[index], process_name, MAX_PATH) &&
 270                     !wcsicmp(process_name, task_list[i]))
 271                 {
 272                     struct pid_close_info info = { pid_list[index] };
 273
 274                     found_process = TRUE;
 275                     if (pid_list[index] == self_pid)
 276                     {
 277                         taskkill_message(STRING_SELF_TERMINATION);
 278                         status_code = 1;
 279                         continue;
 280                     }
 281
 282                     EnumWindows(pid_enum_proc, (LPARAM)&info);
 283                     taskkill_message_printfW(STRING_CLOSE_PROC_SRCH, process_name, pid_list[index]);
 284                 }
 285             }
 286
 287             if (!found_process)
 288             {
 289                 taskkill_message_printfW(STRING_SEARCH_FAILED, task_list[i]);
 290                 status_code = 128;
 291             }
 292         }
 293     }
 294
 295     HeapFree(GetProcessHeap(), 0, pid_list);
 296     return status_code;
 297 }
 298
 299 static int terminate_processes(void)
 300 {
 301     DWORD *pid_list, pid_list_size;
 302     DWORD self_pid = GetCurrentProcessId();
 303     unsigned int i;
 304     int status_code = 0;
 305
 306     pid_list = enumerate_processes(&pid_list_size);
 307     if (!pid_list)
 308     {
 309         taskkill_message(STRING_ENUM_FAILED);
 310         return 1;
 311     }
 312
 313     for (i = 0; i < task_count; i++)
 314     {
 315         WCHAR *p = task_list[i];
 316         BOOL is_numeric = TRUE;
 317
 318         /* Determine whether the string is not numeric. */
 319         while (*p)
 320         {
 321             if (!iswdigit(*p++))
 322             {
 323                 is_numeric = FALSE;
 324                 break;
 325             }
 326         }
 327
 328         if (is_numeric)
 329         {
 330             DWORD pid = wcstol(task_list[i], NULL, 10);
 331             HANDLE process;
 332
 333             if (pid == self_pid)
 334             {
 335                 taskkill_message(STRING_SELF_TERMINATION);
 336                 status_code = 1;
 337                 continue;
 338             }
 339
 340             process = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
 341             if (!process)
 342             {
 343                 taskkill_message_printfW(STRING_SEARCH_FAILED, task_list[i]);
 344                 status_code = 128;
 345                 continue;
 346             }
 347
 348             if (!TerminateProcess(process, 0))
 349             {
 350                 taskkill_message_printfW(STRING_TERMINATE_FAILED, task_list[i]);
 351                 status_code = 1;
 352                 CloseHandle(process);
 353                 continue;
 354             }
 355
 356             taskkill_message_printfW(STRING_TERM_PID_SEARCH, pid);
 357             CloseHandle(process);
 358         }
 359         else
 360         {
 361             DWORD index;
 362             BOOL found_process = FALSE;
 363
 364             for (index = 0; index < pid_list_size; index++)
 365             {
 366                 WCHAR process_name[MAX_PATH];
 367
 368                 if (get_process_name_from_pid(pid_list[index], process_name, MAX_PATH) &&
 369                     !wcsicmp(process_name, task_list[i]))
 370                 {
 371                     HANDLE process;
 372
 373                     if (pid_list[index] == self_pid)
 374                     {
 375                         taskkill_message(STRING_SELF_TERMINATION);
 376                         status_code = 1;
 377                         continue;
 378                     }
 379
 380                     process = OpenProcess(PROCESS_TERMINATE, FALSE, pid_list[index]);
 381                     if (!process)
 382                     {
 383                         taskkill_message_printfW(STRING_SEARCH_FAILED, task_list[i]);
 384                         status_code = 128;
 385                         continue;
 386                     }
 387
 388                     if (!TerminateProcess(process, 0))
 389                     {
 390                         taskkill_message_printfW(STRING_TERMINATE_FAILED, task_list[i]);
 391                         status_code = 1;
 392                         CloseHandle(process);
 393                         continue;
 394                     }
 395
 396                     found_process = TRUE;
 397                     taskkill_message_printfW(STRING_TERM_PROC_SEARCH, task_list[i], pid_list[index]);
 398                     CloseHandle(process);
 399                 }
 400             }
 401
 402             if (!found_process)
 403             {
 404                 taskkill_message_printfW(STRING_SEARCH_FAILED, task_list[i]);
 405                 status_code = 128;
 406             }
 407         }
 408     }
 409
 410     HeapFree(GetProcessHeap(), 0, pid_list);
 411     return status_code;
 412 }
 413
 414 static BOOL add_to_task_list(WCHAR *name)
 415 {
 416     static unsigned int list_size = 16;
 417
 418     if (!task_list)
 419     {
 420         task_list = HeapAlloc(GetProcessHeap(), 0,
 421                                    list_size * sizeof(*task_list));
 422         if (!task_list)
 423             return FALSE;
 424     }
 425     else if (task_count == list_size)
 426     {
 427         void *realloc_list;
 428
 429         list_size *= 2;
 430         realloc_list = HeapReAlloc(GetProcessHeap(), 0, task_list,
 431                                    list_size * sizeof(*task_list));
 432         if (!realloc_list)
 433             return FALSE;
 434
 435         task_list = realloc_list;
 436     }
 437
 438     task_list[task_count++] = name;
 439     return TRUE;
 440 }
 441
 442 /* FIXME Argument processing does not match behavior observed on Windows.
 443  * Stringent argument counting and processing is performed, and unrecognized
 444  * options are detected as parameters when placed after options that accept one. */
 445 static BOOL process_arguments(int argc, WCHAR *argv[])
 446 {
 447     static const WCHAR opForceTerminate[] = {'f',0};
 448     static const WCHAR opImage[] = {'i','m',0};
 449     static const WCHAR opPID[] = {'p','i','d',0};
 450     static const WCHAR opHelp[] = {'?',0};
 451     static const WCHAR opTerminateChildren[] = {'t',0};
 452
 453     if (argc > 1)
 454     {
 455         int i;
 456         WCHAR *argdata;
 457         BOOL has_im = FALSE, has_pid = FALSE;
 458
 459         /* Only the lone help option is recognized. */
 460         if (argc == 2)
 461         {
 462             argdata = argv[1];
 463             if ((*argdata == '/' || *argdata == '-') && !lstrcmpW(opHelp, argdata + 1))
 464             {
 465                 taskkill_message(STRING_USAGE);
 466                 exit(0);
 467             }
 468         }
 469
 470         for (i = 1; i < argc; i++)
 471         {
 472             BOOL got_im = FALSE, got_pid = FALSE;
 473
 474             argdata = argv[i];
 475             if (*argdata != '/' && *argdata != '-')
 476                 goto invalid;
 477             argdata++;
 478
 479             if (!wcsicmp(opTerminateChildren, argdata))
 480                 WINE_FIXME("argument T not supported\n");
 481             if (!wcsicmp(opForceTerminate, argdata))
 482                 force_termination = TRUE;
 483             /* Options /IM and /PID appear to behave identically, except for
 484              * the fact that they cannot be specified at the same time. */
 485             else if ((got_im = !wcsicmp(opImage, argdata)) ||
 486                      (got_pid = !wcsicmp(opPID, argdata)))
 487             {
 488                 if (!argv[i + 1])
 489                 {
 490                     taskkill_message_printfW(STRING_MISSING_PARAM, argv[i]);
 491                     taskkill_message(STRING_USAGE);
 492                     return FALSE;
 493                 }
 494
 495                 if (got_im) has_im = TRUE;
 496                 if (got_pid) has_pid = TRUE;
 497
 498                 if (has_im && has_pid)
 499                 {
 500                     taskkill_message(STRING_MUTUAL_EXCLUSIVE);
 501                     taskkill_message(STRING_USAGE);
 502                     return FALSE;
 503                 }
 504
 505                 if (!add_to_task_list(argv[i + 1]))
 506                     return FALSE;
 507                 i++;
 508             }
 509             else
 510             {
 511                 invalid:
 512                 taskkill_message(STRING_INVALID_OPTION);
 513                 taskkill_message(STRING_USAGE);
 514                 return FALSE;
 515             }
 516         }
 517     }
 518     else
 519     {
 520         taskkill_message(STRING_MISSING_OPTION);
 521         taskkill_message(STRING_USAGE);
 522         return FALSE;
 523     }
 524
 525     return TRUE;
 526 }
 527
 528 int __cdecl wmain(int argc, WCHAR *argv[])
 529 {
 530     int status_code = 0;
 531
 532     if (!process_arguments(argc, argv))
 533     {
 534         HeapFree(GetProcessHeap(), 0, task_list);
 535         return 1;
 536     }
 537
 538     if (force_termination)
 539         status_code = terminate_processes();
 540     else
 541         status_code = send_close_messages();
 542
 543     HeapFree(GetProcessHeap(), 0, task_list);
 544     return status_code;
 545 }