blob: 127c2b5ba36b77ab84de0dc0e138eeeff94d4f0e [file] [log] [blame]
/* **********************************************************
* Copyright (c) 2019 Google, Inc. All rights reserved.
* Copyright (c) 2003-2008 VMware, Inc. All rights reserved.
* **********************************************************/
/*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* * Neither the name of VMware, Inc. nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL VMWARE, INC. OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*/
/* Copyright (c) 2001-2002 Massachusetts Institute of Technology
*
* This file is part of RIO, a research tool that is being supplied
* "as is" without any accompanying services or improvements from MIT.
* MIT makes no representations or warranties, express or implied.
* Permission is hereby granted for non-commercial use of RIO provided
* that you preserve this copyright notice, and you do not mention
* the copyright holders in advertising related to RIO without
* their permission.
*/
/*
* winstats.c -- runs a target executable and gives memory stats at completion
* build like so: cl /nologo winstats.c user32.lib imagehlp.lib
*/
/* FIXME: Unicode support?!?! */
/* xref PR 231843, we target 2003 to get a version of PROCESS_ALL_ACCESS that
* works for all platforms. */
#define _WIN32_WINNT _WIN32_WINNT_WS03
#include <windows.h>
#include <commdlg.h>
#include <imagehlp.h>
#include <stdio.h>
#include <assert.h>
#include <time.h>
#include <tchar.h>
#include "configure.h"
#include "globals_shared.h"
#include "ntdll.h"
/* global vars */
static int limit; /* in seconds */
static BOOL showmem;
static double wallclock; /* in seconds */
#define FP stderr
static void
print_mem_stats(HANDLE h)
{
long secs = (long)wallclock;
VM_COUNTERS mem;
int cpu;
if (!get_process_load_ex(h, &cpu, NULL))
cpu = -1;
get_process_mem_stats(h, &mem);
#if VERBOSE
printf("Process Memory Statistics:\n");
printf("\tPeak virtual size: %6d KB\n", mem.PeakVirtualSize / 1024);
printf("\tPeak working set size: %6d KB\n", mem.PeakWorkingSetSize / 1024);
printf("\tPeak paged pool usage: %6d KB\n", mem.QuotaPeakPagedPoolUsage / 1024);
printf("\tPeak non-paged pool usage: %6d KB\n",
mem.QuotaPeakNonPagedPoolUsage / 1024);
printf("\tPeak pagefile usage: %6d KB\n", mem.PeakPagefileUsage / 1024);
#endif
/* Elapsed real (wall clock) time. */
if (secs >= 3600) { /* One hour -> h:m:s. */
fprintf(FP, "%ld:%02ld:%02ldelapsed ", secs / 3600, (secs % 3600) / 60,
secs % 60);
} else {
fprintf(FP, "%ld:%02ld.%02ldelapsed ", /* -> m:s. */
secs / 60, secs % 60, 0 /* for now */);
}
fprintf(FP, "%d%%CPU \n", cpu);
fprintf(FP, "(%zu tot, %zu RSS, %zu paged, %zu non, %zu swap)k\n",
mem.PeakVirtualSize / 1024, mem.PeakWorkingSetSize / 1024,
mem.QuotaPeakPagedPoolUsage / 1024, mem.QuotaPeakNonPagedPoolUsage / 1024,
mem.PeakPagefileUsage / 1024);
}
#define DEBUGPRINT 0
/* FIXME: would like ^C to kill child process, it doesn't.
* also, child process seems able to read stdin but not to write
* to stdout or stderr (in fact it dies if it tries)
*/
#define HANDLE_CONTROL_C 0
static void
debugbox(char *msg)
{
MessageBox(NULL, TEXT(msg), TEXT("Inject Progress"), MB_OK | MB_TOPMOST);
}
#if HANDLE_CONTROL_C
BOOL WINAPI
HandlerRoutine(DWORD dwCtrlType // control signal type
)
{
printf("Inside HandlerRoutine!\n");
fflush(stdout);
/* GenerateConsoleCtrlEvent(dwCtrlType, phandle);*/
return TRUE;
}
#endif
int
usage(char *us)
{
printf("Usage: %s [-s limit_sec | -m limit_min | -h limit_hr]\n"
" [-silent] <program> <args...>\n",
us);
return 0;
}
#define MAX_CMDLINE 2048
/* we must be a console application in order to have the process
* we launch NOT get a brand new console window!
*/
int __cdecl main(int argc, char *argv[], char *envp[])
{
LPTSTR app_name = NULL;
TCHAR app_cmdline[MAX_CMDLINE];
LPTSTR ch;
int i;
LPTSTR pszCmdLine = GetCommandLine();
PLOADED_IMAGE li;
STARTUPINFO si;
PROCESS_INFORMATION pi;
HANDLE phandle;
BOOL success;
DWORD wait_result;
int arg_offs = 1;
time_t start_time, end_time;
STARTUPINFO mysi;
GetStartupInfo(&mysi);
/* parse args */
limit = 0;
showmem = TRUE;
if (argc < 2) {
return usage(argv[0]);
}
while (argv[arg_offs][0] == '-') {
if (strcmp(argv[arg_offs], "-s") == 0) {
if (argc <= arg_offs + 1)
return usage(argv[0]);
limit = atoi(argv[arg_offs + 1]);
arg_offs += 2;
} else if (strcmp(argv[arg_offs], "-m") == 0) {
if (argc <= arg_offs + 1)
return usage(argv[0]);
limit = atoi(argv[arg_offs + 1]) * 60;
arg_offs += 2;
} else if (strcmp(argv[arg_offs], "-h") == 0) {
if (argc <= arg_offs + 1)
return usage(argv[0]);
limit = atoi(argv[arg_offs + 1]) * 3600;
arg_offs += 2;
} else if (strcmp(argv[arg_offs], "-v") == 0) {
/* just ignore -v, only here for compatibility with texec */
arg_offs += 1;
} else if (strcmp(argv[arg_offs], "-silent") == 0) {
showmem = FALSE;
arg_offs += 1;
} else {
return usage(argv[0]);
}
if (limit < 0) {
return usage(argv[0]);
}
if (argc - arg_offs < 1) {
return usage(argv[0]);
}
}
/* we don't want quotes included in our
* application path string (app_name), but we do want to put
* quotes around every member of the command line
*/
app_name = argv[arg_offs];
if (app_name[0] == '\"' || app_name[0] == '\'' || app_name[0] == '`') {
/* remove quotes */
app_name++;
app_name[strlen(app_name) - 1] = '\0';
}
/* note that we want target app name as part of cmd line
* (FYI: if we were using WinMain, the pzsCmdLine passed in
* does not have our own app name in it)
* since cygwin shell ends up putting extra quote characters, etc.
* in pszCmdLine ('"foo"' => "\"foo\""), we can't easily walk past
* the 1st 2 args (our path and the dll path), so we reconstruct
* the cmd line from scratch:
*/
ch = app_cmdline;
ch += _snprintf(app_cmdline, MAX_CMDLINE, "\"%s\"", app_name);
for (i = arg_offs + 1; i < argc; i++)
ch += _snprintf(ch, MAX_CMDLINE - (ch - app_cmdline), " \"%s\"", argv[i]);
assert(ch - app_cmdline < MAX_CMDLINE);
#if DEBUGPRINT
printf("Running \"%s\"\n", app_cmdline);
fflush(stdout);
#endif
#if HANDLE_CONTROL_C
if (!SetConsoleCtrlHandler(HandlerRoutine, TRUE)) {
debugbox("SetConsoleCtrlHandler failed");
return 1;
}
{
int flags;
/* FIXME: hStdInput apparently is not the right handle...how do I get
* the right handle?!?
*/
if (!GetConsoleMode(mysi.hStdInput, &flags)) {
debugbox("GetConsoleMode failed");
return 1;
}
printf("console mode flags are: 0x%08x\n", flags);
}
#endif
if (li = ImageLoad(app_name, NULL)) {
ImageUnload(li);
} else {
_snprintf(app_cmdline, MAX_CMDLINE, "Failed to load executable image \"%s\"",
app_name);
debugbox(app_cmdline);
return 1;
}
/* Launch the application process. */
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
si.dwFlags = STARTF_USESTDHANDLES;
si.hStdInput = mysi.hStdInput;
si.hStdOutput = mysi.hStdOutput;
si.hStdError = mysi.hStdError;
/* Must specify TRUE for bInheritHandles so child inherits stdin! */
if (!CreateProcess(app_name, app_cmdline, NULL, NULL, TRUE, CREATE_SUSPENDED, NULL,
NULL, &si, &pi)) {
debugbox("Failed to launch application");
return 1;
}
if ((phandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pi.dwProcessId)) == NULL) {
debugbox("Cannot open application process");
TerminateProcess(pi.hProcess, 0);
return 1;
}
#if DEBUGPRINT
printf("Successful at starting process\n");
fflush(stdout);
#endif
success = FALSE;
__try {
start_time = time(NULL);
/* resume the suspended app process so its main thread can run */
ResumeThread(pi.hThread);
/* detach from the app process */
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
/* now wait for app process to finish */
wait_result =
WaitForSingleObject(phandle, (limit == 0) ? INFINITE : (limit * 1000));
end_time = time(NULL);
wallclock = difftime(end_time, start_time);
if (wait_result == WAIT_OBJECT_0)
success = TRUE;
else
printf("Timeout after %d seconds\n", limit);
} __finally {
/* FIXME: this is my attempt to get ^C, but it doesn't work... */
#if HANDLE_CONTROL_C
if (!success) {
printf("Terminating child process!\n");
fflush(stdout);
TerminateProcess(phandle, 0);
} else
printf("Injector exiting peacefully\n");
#endif
if (showmem)
print_mem_stats(phandle);
if (!success) {
/* kill the child */
TerminateProcess(phandle, 0);
}
CloseHandle(phandle);
#if DEBUGPRINT
fflush(stdout);
#endif
}
return 0;
}