| 1 | /*
|
|---|
| 2 | * Copyright (c) 2014 Vojtech Horky
|
|---|
| 3 | * All rights reserved.
|
|---|
| 4 | *
|
|---|
| 5 | * Redistribution and use in source and binary forms, with or without
|
|---|
| 6 | * modification, are permitted provided that the following conditions
|
|---|
| 7 | * are met:
|
|---|
| 8 | *
|
|---|
| 9 | * - Redistributions of source code must retain the above copyright
|
|---|
| 10 | * notice, this list of conditions and the following disclaimer.
|
|---|
| 11 | * - Redistributions in binary form must reproduce the above copyright
|
|---|
| 12 | * notice, this list of conditions and the following disclaimer in the
|
|---|
| 13 | * documentation and/or other materials provided with the distribution.
|
|---|
| 14 | * - The name of the author may not be used to endorse or promote products
|
|---|
| 15 | * derived from this software without specific prior written permission.
|
|---|
| 16 | *
|
|---|
| 17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|---|
| 18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|---|
| 19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|---|
| 20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|---|
| 21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|---|
| 22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|---|
| 23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|---|
| 24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|---|
| 25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|---|
| 26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|---|
| 27 | */
|
|---|
| 28 |
|
|---|
| 29 | /** @file
|
|---|
| 30 | *
|
|---|
| 31 | * Windows-specific functions for test execution via the popen() system call.
|
|---|
| 32 | */
|
|---|
| 33 |
|
|---|
| 34 | /*
|
|---|
| 35 | * Code inspired by Creating a Child Process with Redirected Input and Output:
|
|---|
| 36 | * http://msdn.microsoft.com/en-us/library/ms682499%28VS.85%29.aspx
|
|---|
| 37 | */
|
|---|
| 38 |
|
|---|
| 39 | #include "../internal.h"
|
|---|
| 40 |
|
|---|
| 41 | #pragma warning(push, 0)
|
|---|
| 42 | #include <windows.h>
|
|---|
| 43 | #include <tchar.h>
|
|---|
| 44 | #include <stdio.h>
|
|---|
| 45 | #include <strsafe.h>
|
|---|
| 46 | #pragma warning(pop)
|
|---|
| 47 |
|
|---|
| 48 |
|
|---|
| 49 |
|
|---|
| 50 | /** Maximum size of stdout we are able to capture. */
|
|---|
| 51 | #define OUTPUT_BUFFER_SIZE 8192
|
|---|
| 52 |
|
|---|
| 53 | /** Maximum command-line length. */
|
|---|
| 54 | #define PCUT_COMMAND_LINE_BUFFER_SIZE 256
|
|---|
| 55 |
|
|---|
| 56 | /** Buffer for assertion and other error messages. */
|
|---|
| 57 | static char error_message_buffer[OUTPUT_BUFFER_SIZE];
|
|---|
| 58 |
|
|---|
| 59 | /** Buffer for stdout from the test. */
|
|---|
| 60 | static char extra_output_buffer[OUTPUT_BUFFER_SIZE];
|
|---|
| 61 |
|
|---|
| 62 | /** Prepare for a new test.
|
|---|
| 63 | *
|
|---|
| 64 | * @param test Test that is about to be run.
|
|---|
| 65 | */
|
|---|
| 66 | static void before_test_start(pcut_item_t *test) {
|
|---|
| 67 | pcut_report_test_start(test);
|
|---|
| 68 |
|
|---|
| 69 | memset(error_message_buffer, 0, OUTPUT_BUFFER_SIZE);
|
|---|
| 70 | memset(extra_output_buffer, 0, OUTPUT_BUFFER_SIZE);
|
|---|
| 71 | }
|
|---|
| 72 |
|
|---|
| 73 | /** Report that a certain function failed.
|
|---|
| 74 | *
|
|---|
| 75 | * @param test Current test.
|
|---|
| 76 | * @param failed_function_name Name of the failed function.
|
|---|
| 77 | */
|
|---|
| 78 | static void report_func_fail(pcut_item_t *test, const char *failed_function_name) {
|
|---|
| 79 | /* TODO: get error description. */
|
|---|
| 80 | pcut_snprintf(error_message_buffer, OUTPUT_BUFFER_SIZE - 1,
|
|---|
| 81 | "%s failed: %s.", failed_function_name, "unknown reason");
|
|---|
| 82 | pcut_report_test_done(test, PCUT_OUTCOME_INTERNAL_ERROR, error_message_buffer, NULL, NULL);
|
|---|
| 83 | }
|
|---|
| 84 |
|
|---|
| 85 | /** Read full buffer from given file descriptor.
|
|---|
| 86 | *
|
|---|
| 87 | * This function exists to overcome the possibility that read() may
|
|---|
| 88 | * not fill the full length of the provided buffer even when EOF is
|
|---|
| 89 | * not reached.
|
|---|
| 90 | *
|
|---|
| 91 | * @param fd Opened file descriptor.
|
|---|
| 92 | * @param buffer Buffer to store data into.
|
|---|
| 93 | * @param buffer_size Size of the @p buffer in bytes.
|
|---|
| 94 | * @return Number of actually read bytes.
|
|---|
| 95 | */
|
|---|
| 96 | static size_t read_all(HANDLE fd, char *buffer, size_t buffer_size) {
|
|---|
| 97 | DWORD actually_read;
|
|---|
| 98 | char *buffer_start = buffer;
|
|---|
| 99 | BOOL okay = FALSE;
|
|---|
| 100 |
|
|---|
| 101 | do {
|
|---|
| 102 | okay = ReadFile(fd, buffer, buffer_size, &actually_read, NULL);
|
|---|
| 103 | if (!okay) {
|
|---|
| 104 | break;
|
|---|
| 105 | }
|
|---|
| 106 | if (actually_read > 0) {
|
|---|
| 107 | buffer += actually_read;
|
|---|
| 108 | buffer_size -= actually_read;
|
|---|
| 109 | if (buffer_size == 0) {
|
|---|
| 110 | break;
|
|---|
| 111 | }
|
|---|
| 112 | }
|
|---|
| 113 | } while (actually_read > 0);
|
|---|
| 114 | if (buffer_start != buffer) {
|
|---|
| 115 | if (*(buffer - 1) == 10) {
|
|---|
| 116 | *(buffer - 1) = 0;
|
|---|
| 117 | buffer--;
|
|---|
| 118 | }
|
|---|
| 119 | }
|
|---|
| 120 | return buffer - buffer_start;
|
|---|
| 121 | }
|
|---|
| 122 |
|
|---|
| 123 | struct test_output_data {
|
|---|
| 124 | HANDLE pipe_stdout;
|
|---|
| 125 | HANDLE pipe_stderr;
|
|---|
| 126 | char *output_buffer;
|
|---|
| 127 | size_t output_buffer_size;
|
|---|
| 128 | };
|
|---|
| 129 |
|
|---|
| 130 | static DWORD WINAPI read_test_output_on_background(LPVOID test_output_data_ptr) {
|
|---|
| 131 | size_t stderr_size = 0;
|
|---|
| 132 | struct test_output_data *test_output_data = (struct test_output_data *) test_output_data_ptr;
|
|---|
| 133 |
|
|---|
| 134 | stderr_size = read_all(test_output_data->pipe_stderr,
|
|---|
| 135 | test_output_data->output_buffer,
|
|---|
| 136 | test_output_data->output_buffer_size - 1);
|
|---|
| 137 | read_all(test_output_data->pipe_stdout,
|
|---|
| 138 | test_output_data->output_buffer,
|
|---|
| 139 | test_output_data->output_buffer_size - 1 - stderr_size);
|
|---|
| 140 |
|
|---|
| 141 | return 0;
|
|---|
| 142 | }
|
|---|
| 143 |
|
|---|
| 144 | /** Run the test as a new process and report the result.
|
|---|
| 145 | *
|
|---|
| 146 | * @param self_path Path to itself, that is to current binary.
|
|---|
| 147 | * @param test Test to be run.
|
|---|
| 148 | */
|
|---|
| 149 | int pcut_run_test_forking(const char *self_path, pcut_item_t *test) {
|
|---|
| 150 | /* TODO: clean-up if something goes wrong "in the middle" */
|
|---|
| 151 | BOOL okay = FALSE;
|
|---|
| 152 | DWORD rc;
|
|---|
| 153 | int outcome;
|
|---|
| 154 | int timed_out;
|
|---|
| 155 | int time_out_millis;
|
|---|
| 156 | SECURITY_ATTRIBUTES security_attributes;
|
|---|
| 157 | HANDLE link_stdout[2] = { NULL, NULL };
|
|---|
| 158 | HANDLE link_stderr[2] = { NULL, NULL };
|
|---|
| 159 | HANDLE link_stdin[2] = { NULL, NULL };
|
|---|
| 160 | PROCESS_INFORMATION process_info;
|
|---|
| 161 | STARTUPINFO start_info;
|
|---|
| 162 | char command[PCUT_COMMAND_LINE_BUFFER_SIZE];
|
|---|
| 163 | struct test_output_data test_output_data;
|
|---|
| 164 | HANDLE test_output_thread_reader;
|
|---|
| 165 |
|
|---|
| 166 |
|
|---|
| 167 | before_test_start(test);
|
|---|
| 168 |
|
|---|
| 169 | /* Pipe handles are inherited. */
|
|---|
| 170 | security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
|
|---|
| 171 | security_attributes.bInheritHandle = TRUE;
|
|---|
| 172 | security_attributes.lpSecurityDescriptor = NULL;
|
|---|
| 173 |
|
|---|
| 174 | /* Create pipe for stdout, make sure it is not inherited. */
|
|---|
| 175 | okay = CreatePipe(&link_stdout[0], &link_stdout[1], &security_attributes, 0);
|
|---|
| 176 | if (!okay) {
|
|---|
| 177 | report_func_fail(test, "CreatePipe(/* stdout */)");
|
|---|
| 178 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 179 | }
|
|---|
| 180 | okay = SetHandleInformation(link_stdout[0], HANDLE_FLAG_INHERIT, 0);
|
|---|
| 181 | if (!okay) {
|
|---|
| 182 | report_func_fail(test, "SetHandleInformation(/* stdout */)");
|
|---|
| 183 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 184 | }
|
|---|
| 185 |
|
|---|
| 186 | /* Create pipe for stderr, make sure it is not inherited. */
|
|---|
| 187 | okay = CreatePipe(&link_stderr[0], &link_stderr[1], &security_attributes, 0);
|
|---|
| 188 | if (!okay) {
|
|---|
| 189 | report_func_fail(test, "CreatePipe(/* stderr */)");
|
|---|
| 190 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 191 | }
|
|---|
| 192 | okay = SetHandleInformation(link_stderr[0], HANDLE_FLAG_INHERIT, 0);
|
|---|
| 193 | if (!okay) {
|
|---|
| 194 | report_func_fail(test, "SetHandleInformation(/* stderr */)");
|
|---|
| 195 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 196 | }
|
|---|
| 197 |
|
|---|
| 198 | /* Create pipe for stdin, make sure it is not inherited. */
|
|---|
| 199 | okay = CreatePipe(&link_stdin[0], &link_stdin[1], &security_attributes, 0);
|
|---|
| 200 | if (!okay) {
|
|---|
| 201 | report_func_fail(test, "CreatePipe(/* stdin */)");
|
|---|
| 202 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 203 | }
|
|---|
| 204 | okay = SetHandleInformation(link_stdin[1], HANDLE_FLAG_INHERIT, 0);
|
|---|
| 205 | if (!okay) {
|
|---|
| 206 | report_func_fail(test, "SetHandleInformation(/* stdin */)");
|
|---|
| 207 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 208 | }
|
|---|
| 209 |
|
|---|
| 210 | /* Prepare information for the child process. */
|
|---|
| 211 | ZeroMemory(&process_info, sizeof(PROCESS_INFORMATION));
|
|---|
| 212 | ZeroMemory(&start_info, sizeof(STARTUPINFO));
|
|---|
| 213 | start_info.cb = sizeof(STARTUPINFO);
|
|---|
| 214 | start_info.hStdError = link_stderr[1];
|
|---|
| 215 | start_info.hStdOutput = link_stdout[1];
|
|---|
| 216 | start_info.hStdInput = link_stdin[0];
|
|---|
| 217 | start_info.dwFlags |= STARTF_USESTDHANDLES;
|
|---|
| 218 |
|
|---|
| 219 | /* Format the command line. */
|
|---|
| 220 | pcut_snprintf(command, PCUT_COMMAND_LINE_BUFFER_SIZE - 1,
|
|---|
| 221 | "\"%s\" -t%d", self_path, test->id);
|
|---|
| 222 |
|
|---|
| 223 | /* Run the process. */
|
|---|
| 224 | okay = CreateProcess(NULL, command, NULL, NULL, TRUE, 0, NULL, NULL,
|
|---|
| 225 | &start_info, &process_info);
|
|---|
| 226 |
|
|---|
| 227 | if (!okay) {
|
|---|
| 228 | report_func_fail(test, "CreateProcess()");
|
|---|
| 229 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 230 | }
|
|---|
| 231 |
|
|---|
| 232 | // FIXME: kill the process on error
|
|---|
| 233 |
|
|---|
| 234 | /* Close handles to the first thread. */
|
|---|
| 235 | CloseHandle(process_info.hThread);
|
|---|
| 236 |
|
|---|
| 237 | /* Close the other ends of the pipes. */
|
|---|
| 238 | okay = CloseHandle(link_stdout[1]);
|
|---|
| 239 | if (!okay) {
|
|---|
| 240 | report_func_fail(test, "CloseHandle(/* stdout */)");
|
|---|
| 241 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 242 | }
|
|---|
| 243 | okay = CloseHandle(link_stderr[1]);
|
|---|
| 244 | if (!okay) {
|
|---|
| 245 | report_func_fail(test, "CloseHandle(/* stderr */)");
|
|---|
| 246 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 247 | }
|
|---|
| 248 | okay = CloseHandle(link_stdin[0]);
|
|---|
| 249 | if (!okay) {
|
|---|
| 250 | report_func_fail(test, "CloseHandle(/* stdin */)");
|
|---|
| 251 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 252 | }
|
|---|
| 253 |
|
|---|
| 254 | /*
|
|---|
| 255 | * Read data from stdout and stderr.
|
|---|
| 256 | * We need to do this in a separate thread to allow the
|
|---|
| 257 | * time-out to work correctly.
|
|---|
| 258 | * Probably, this can be done with asynchronous I/O but
|
|---|
| 259 | * this works for now pretty well.
|
|---|
| 260 | */
|
|---|
| 261 | test_output_data.pipe_stderr = link_stderr[0];
|
|---|
| 262 | test_output_data.pipe_stdout = link_stdout[0];
|
|---|
| 263 | test_output_data.output_buffer = extra_output_buffer;
|
|---|
| 264 | test_output_data.output_buffer_size = OUTPUT_BUFFER_SIZE;
|
|---|
| 265 |
|
|---|
| 266 | test_output_thread_reader = CreateThread(NULL, 0,
|
|---|
| 267 | read_test_output_on_background, &test_output_data,
|
|---|
| 268 | 0, NULL);
|
|---|
| 269 |
|
|---|
| 270 | if (test_output_thread_reader == NULL) {
|
|---|
| 271 | report_func_fail(test, "CreateThread(/* read test stdout */)");
|
|---|
| 272 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 273 | }
|
|---|
| 274 |
|
|---|
| 275 | /* Wait for the process to terminate. */
|
|---|
| 276 | timed_out = 0;
|
|---|
| 277 | time_out_millis = pcut_get_test_timeout(test) * 1000;
|
|---|
| 278 | rc = WaitForSingleObject(process_info.hProcess, time_out_millis);
|
|---|
| 279 | PCUT_DEBUG("Waiting for test %s (%dms) returned %d.", test->name, time_out_millis, rc);
|
|---|
| 280 | if (rc == WAIT_TIMEOUT) {
|
|---|
| 281 | /* We timed-out: kill the process and wait for its termination again. */
|
|---|
| 282 | timed_out = 1;
|
|---|
| 283 | okay = TerminateProcess(process_info.hProcess, 5);
|
|---|
| 284 | if (!okay) {
|
|---|
| 285 | report_func_fail(test, "TerminateProcess(/* PROCESS_INFORMATION.hProcess */)");
|
|---|
| 286 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 287 | }
|
|---|
| 288 | rc = WaitForSingleObject(process_info.hProcess, INFINITE);
|
|---|
| 289 | }
|
|---|
| 290 | if (rc != WAIT_OBJECT_0) {
|
|---|
| 291 | report_func_fail(test, "WaitForSingleObject(/* PROCESS_INFORMATION.hProcess */)");
|
|---|
| 292 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 293 | }
|
|---|
| 294 |
|
|---|
| 295 | /* Get the return code and convert it to outcome. */
|
|---|
| 296 | okay = GetExitCodeProcess(process_info.hProcess, &rc);
|
|---|
| 297 | if (!okay) {
|
|---|
| 298 | report_func_fail(test, "GetExitCodeProcess()");
|
|---|
| 299 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 300 | }
|
|---|
| 301 |
|
|---|
| 302 | if (rc == 0) {
|
|---|
| 303 | outcome = PCUT_OUTCOME_PASS;
|
|---|
| 304 | } else if ((rc > 0) && (rc < 10) && !timed_out) {
|
|---|
| 305 | outcome = PCUT_OUTCOME_FAIL;
|
|---|
| 306 | } else {
|
|---|
| 307 | outcome = PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 308 | }
|
|---|
| 309 |
|
|---|
| 310 | /* Wait for the reader thread (shall be terminated by now). */
|
|---|
| 311 | rc = WaitForSingleObject(test_output_thread_reader, INFINITE);
|
|---|
| 312 | if (rc != WAIT_OBJECT_0) {
|
|---|
| 313 | report_func_fail(test, "WaitForSingleObject(/* stdout reader thread */)");
|
|---|
| 314 | return PCUT_OUTCOME_INTERNAL_ERROR;
|
|---|
| 315 | }
|
|---|
| 316 |
|
|---|
| 317 | pcut_report_test_done_unparsed(test, outcome, extra_output_buffer, OUTPUT_BUFFER_SIZE);
|
|---|
| 318 |
|
|---|
| 319 | return outcome;
|
|---|
| 320 | }
|
|---|
| 321 |
|
|---|
| 322 | void pcut_hook_before_test(pcut_item_t *test) {
|
|---|
| 323 | PCUT_UNUSED(test);
|
|---|
| 324 |
|
|---|
| 325 | /*
|
|---|
| 326 | * Prevent displaying the dialog informing the user that the
|
|---|
| 327 | * program unexpectedly failed.
|
|---|
| 328 | */
|
|---|
| 329 | SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
|
|---|
| 330 | }
|
|---|
