|
160
|
1
|
|
|
2 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
|
|
|
3 *
|
|
|
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
5 * of this software and associated documentation files (the "Software"), to
|
|
|
6 * deal in the Software without restriction, including without limitation the
|
|
|
7 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
|
8 * sell copies of the Software, and to permit persons to whom the Software is
|
|
|
9 * furnished to do so, subject to the following conditions:
|
|
|
10 *
|
|
|
11 * The above copyright notice and this permission notice shall be included in
|
|
|
12 * all copies or substantial portions of the Software.
|
|
|
13 *
|
|
|
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
19 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
20 * IN THE SOFTWARE.
|
|
|
21 */
|
|
|
22
|
|
|
23 #include "uv.h"
|
|
|
24 #include "task.h"
|
|
|
25 #include <errno.h>
|
|
|
26 #include <fcntl.h>
|
|
|
27 #include <stdio.h>
|
|
|
28 #include <stdlib.h>
|
|
|
29 #include <string.h>
|
|
|
30
|
|
|
31 #ifdef _WIN32
|
|
|
32 # include <shellapi.h>
|
|
|
33 # include <wchar.h>
|
|
|
34 typedef BOOL (WINAPI *sCompareObjectHandles)(_In_ HANDLE, _In_ HANDLE);
|
|
|
35 # define unlink _unlink
|
|
|
36 # define putenv _putenv
|
|
|
37 # define close _close
|
|
|
38 #else
|
|
|
39 # include <unistd.h>
|
|
|
40 # include <sys/wait.h>
|
|
|
41 #endif
|
|
|
42
|
|
|
43
|
|
|
44 static int close_cb_called;
|
|
|
45 static int exit_cb_called;
|
|
|
46 static uv_process_t process;
|
|
|
47 static uv_timer_t timer;
|
|
|
48 static uv_process_options_t options;
|
|
|
49 static char exepath[1024];
|
|
|
50 static size_t exepath_size = 1024;
|
|
|
51 static char* args[5];
|
|
|
52 static int no_term_signal;
|
|
|
53 static int timer_counter;
|
|
|
54 static uv_tcp_t tcp_server;
|
|
|
55
|
|
|
56 #define OUTPUT_SIZE 1024
|
|
|
57 static char output[OUTPUT_SIZE];
|
|
|
58 static int output_used;
|
|
|
59
|
|
|
60
|
|
|
61 static void close_cb(uv_handle_t* handle) {
|
|
|
62 printf("close_cb\n");
|
|
|
63 close_cb_called++;
|
|
|
64 }
|
|
|
65
|
|
|
66 static void exit_cb(uv_process_t* process,
|
|
|
67 int64_t exit_status,
|
|
|
68 int term_signal) {
|
|
|
69 printf("exit_cb\n");
|
|
|
70 exit_cb_called++;
|
|
|
71 ASSERT_EQ(1, exit_status);
|
|
|
72 ASSERT_OK(term_signal);
|
|
|
73 uv_close((uv_handle_t*) process, close_cb);
|
|
|
74 }
|
|
|
75
|
|
|
76
|
|
|
77 static void fail_cb(uv_process_t* process,
|
|
|
78 int64_t exit_status,
|
|
|
79 int term_signal) {
|
|
|
80 ASSERT(0 && "fail_cb called");
|
|
|
81 }
|
|
|
82
|
|
|
83
|
|
|
84 static void kill_cb(uv_process_t* process,
|
|
|
85 int64_t exit_status,
|
|
|
86 int term_signal) {
|
|
|
87 int err;
|
|
|
88
|
|
|
89 printf("exit_cb\n");
|
|
|
90 exit_cb_called++;
|
|
|
91 #ifdef _WIN32
|
|
|
92 ASSERT_EQ(1, exit_status);
|
|
|
93 #else
|
|
|
94 ASSERT_OK(exit_status);
|
|
|
95 #endif
|
|
|
96 #if defined(__APPLE__) || defined(__MVS__)
|
|
|
97 /*
|
|
|
98 * At least starting with Darwin Kernel Version 16.4.0, sending a SIGTERM to a
|
|
|
99 * process that is still starting up kills it with SIGKILL instead of SIGTERM.
|
|
|
100 * See: https://github.com/libuv/libuv/issues/1226
|
|
|
101 */
|
|
|
102 ASSERT(no_term_signal || term_signal == SIGTERM || term_signal == SIGKILL);
|
|
|
103 #else
|
|
|
104 ASSERT(no_term_signal || term_signal == SIGTERM);
|
|
|
105 #endif
|
|
|
106 uv_close((uv_handle_t*) process, close_cb);
|
|
|
107
|
|
|
108 /*
|
|
|
109 * Sending signum == 0 should check if the
|
|
|
110 * child process is still alive, not kill it.
|
|
|
111 * This process should be dead.
|
|
|
112 */
|
|
|
113 err = uv_kill(process->pid, 0);
|
|
|
114 ASSERT_EQ(err, UV_ESRCH);
|
|
|
115 }
|
|
|
116
|
|
|
117 static void detach_failure_cb(uv_process_t* process,
|
|
|
118 int64_t exit_status,
|
|
|
119 int term_signal) {
|
|
|
120 printf("detach_cb\n");
|
|
|
121 exit_cb_called++;
|
|
|
122 }
|
|
|
123
|
|
|
124 static void on_alloc(uv_handle_t* handle,
|
|
|
125 size_t suggested_size,
|
|
|
126 uv_buf_t* buf) {
|
|
|
127 buf->base = output + output_used;
|
|
|
128 buf->len = OUTPUT_SIZE - output_used;
|
|
|
129 }
|
|
|
130
|
|
|
131
|
|
|
132 static void on_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
|
|
|
133 if (nread > 0) {
|
|
|
134 output_used += nread;
|
|
|
135 } else if (nread < 0) {
|
|
|
136 ASSERT_EQ(nread, UV_EOF);
|
|
|
137 uv_close((uv_handle_t*) tcp, close_cb);
|
|
|
138 }
|
|
|
139 }
|
|
|
140
|
|
|
141
|
|
|
142 static void on_read_once(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
|
|
|
143 uv_read_stop(tcp);
|
|
|
144 on_read(tcp, nread, buf);
|
|
|
145 }
|
|
|
146
|
|
|
147
|
|
|
148 static void write_cb(uv_write_t* req, int status) {
|
|
|
149 ASSERT_OK(status);
|
|
|
150 uv_close((uv_handle_t*) req->handle, close_cb);
|
|
|
151 }
|
|
|
152
|
|
|
153
|
|
|
154 static void write_null_cb(uv_write_t* req, int status) {
|
|
|
155 ASSERT_OK(status);
|
|
|
156 }
|
|
|
157
|
|
|
158
|
|
|
159 static void init_process_options(char* test, uv_exit_cb exit_cb) {
|
|
|
160 /* Note spawn_helper1 defined in test/run-tests.c */
|
|
|
161 int r = uv_exepath(exepath, &exepath_size);
|
|
|
162 ASSERT_OK(r);
|
|
|
163 exepath[exepath_size] = '\0';
|
|
|
164 args[0] = exepath;
|
|
|
165 args[1] = test;
|
|
|
166 args[2] = NULL;
|
|
|
167 args[3] = NULL;
|
|
|
168 args[4] = NULL;
|
|
|
169 options.file = exepath;
|
|
|
170 options.args = args;
|
|
|
171 options.exit_cb = exit_cb;
|
|
|
172 options.flags = 0;
|
|
|
173 }
|
|
|
174
|
|
|
175
|
|
|
176 static void timer_cb(uv_timer_t* handle) {
|
|
|
177 uv_process_kill(&process, SIGTERM);
|
|
|
178 uv_close((uv_handle_t*) handle, close_cb);
|
|
|
179 }
|
|
|
180
|
|
|
181
|
|
|
182 static void timer_counter_cb(uv_timer_t* handle) {
|
|
|
183 ++timer_counter;
|
|
|
184 }
|
|
|
185
|
|
|
186
|
|
|
187 TEST_IMPL(spawn_fails) {
|
|
|
188 int r;
|
|
|
189
|
|
|
190 init_process_options("", fail_cb);
|
|
|
191 options.file = options.args[0] = "program-that-had-better-not-exist";
|
|
|
192
|
|
|
193 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
194 ASSERT(r == UV_ENOENT || r == UV_EACCES);
|
|
|
195 ASSERT_OK(uv_is_active((uv_handle_t*) &process));
|
|
|
196 uv_close((uv_handle_t*) &process, NULL);
|
|
|
197 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
198
|
|
|
199 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
200 return 0;
|
|
|
201 }
|
|
|
202
|
|
|
203
|
|
|
204 #ifndef _WIN32
|
|
|
205 TEST_IMPL(spawn_fails_check_for_waitpid_cleanup) {
|
|
|
206 int r;
|
|
|
207 int status;
|
|
|
208 int err;
|
|
|
209
|
|
|
210 init_process_options("", fail_cb);
|
|
|
211 options.file = options.args[0] = "program-that-had-better-not-exist";
|
|
|
212
|
|
|
213 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
214 ASSERT(r == UV_ENOENT || r == UV_EACCES);
|
|
|
215 ASSERT_OK(uv_is_active((uv_handle_t*) &process));
|
|
|
216 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
217
|
|
|
218 /* verify the child is successfully cleaned up within libuv */
|
|
|
219 do
|
|
|
220 err = waitpid(process.pid, &status, 0);
|
|
|
221 while (err == -1 && errno == EINTR);
|
|
|
222
|
|
|
223 ASSERT_EQ(err, -1);
|
|
|
224 ASSERT_EQ(errno, ECHILD);
|
|
|
225
|
|
|
226 uv_close((uv_handle_t*) &process, NULL);
|
|
|
227 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
228
|
|
|
229 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
230 return 0;
|
|
|
231 }
|
|
|
232 #endif
|
|
|
233
|
|
|
234
|
|
|
235 TEST_IMPL(spawn_empty_env) {
|
|
|
236 char* env[1];
|
|
|
237
|
|
|
238 /* The autotools dynamic library build requires the presence of
|
|
|
239 * DYLD_LIBARY_PATH (macOS) or LD_LIBRARY_PATH/LIBPATH (other Unices)
|
|
|
240 * in the environment, but of course that doesn't work with
|
|
|
241 * the empty environment that we're testing here.
|
|
|
242 */
|
|
|
243 if (NULL != getenv("DYLD_LIBRARY_PATH") ||
|
|
|
244 NULL != getenv("LD_LIBRARY_PATH") ||
|
|
|
245 NULL != getenv("LIBPATH")) {
|
|
|
246 RETURN_SKIP("doesn't work with DYLD_LIBRARY_PATH/LD_LIBRARY_PATH/LIBPATH");
|
|
|
247 }
|
|
|
248
|
|
|
249 init_process_options("spawn_helper1", exit_cb);
|
|
|
250 options.env = env;
|
|
|
251 env[0] = NULL;
|
|
|
252
|
|
|
253 ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options));
|
|
|
254 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
255
|
|
|
256 ASSERT_EQ(1, exit_cb_called);
|
|
|
257 ASSERT_EQ(1, close_cb_called);
|
|
|
258
|
|
|
259 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
260 return 0;
|
|
|
261 }
|
|
|
262
|
|
|
263
|
|
|
264 TEST_IMPL(spawn_exit_code) {
|
|
|
265 int r;
|
|
|
266
|
|
|
267 init_process_options("spawn_helper1", exit_cb);
|
|
|
268
|
|
|
269 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
270 ASSERT_OK(r);
|
|
|
271
|
|
|
272 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
273 ASSERT_OK(r);
|
|
|
274
|
|
|
275 ASSERT_EQ(1, exit_cb_called);
|
|
|
276 ASSERT_EQ(1, close_cb_called);
|
|
|
277
|
|
|
278 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
279 return 0;
|
|
|
280 }
|
|
|
281
|
|
|
282
|
|
|
283 TEST_IMPL(spawn_stdout) {
|
|
|
284 int r;
|
|
|
285 uv_pipe_t out;
|
|
|
286 uv_stdio_container_t stdio[2];
|
|
|
287
|
|
|
288 init_process_options("spawn_helper2", exit_cb);
|
|
|
289
|
|
|
290 uv_pipe_init(uv_default_loop(), &out, 0);
|
|
|
291 options.stdio = stdio;
|
|
|
292 options.stdio[0].flags = UV_IGNORE;
|
|
|
293 options.stdio[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
|
|
|
294 options.stdio[1].data.stream = (uv_stream_t*) &out;
|
|
|
295 options.stdio_count = 2;
|
|
|
296
|
|
|
297 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
298 ASSERT_OK(r);
|
|
|
299
|
|
|
300 r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
|
|
|
301 ASSERT_OK(r);
|
|
|
302
|
|
|
303 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
304 ASSERT_OK(r);
|
|
|
305
|
|
|
306 ASSERT_EQ(1, exit_cb_called);
|
|
|
307 ASSERT_EQ(2, close_cb_called); /* Once for process once for the pipe. */
|
|
|
308 printf("output is: %s", output);
|
|
|
309 ASSERT_OK(strcmp("hello world\n", output));
|
|
|
310
|
|
|
311 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
312 return 0;
|
|
|
313 }
|
|
|
314
|
|
|
315
|
|
|
316 TEST_IMPL(spawn_stdout_to_file) {
|
|
|
317 int r;
|
|
|
318 uv_file file;
|
|
|
319 uv_fs_t fs_req;
|
|
|
320 uv_stdio_container_t stdio[2];
|
|
|
321 uv_buf_t buf;
|
|
|
322
|
|
|
323 /* Setup. */
|
|
|
324 unlink("stdout_file");
|
|
|
325
|
|
|
326 init_process_options("spawn_helper2", exit_cb);
|
|
|
327
|
|
|
328 r = uv_fs_open(NULL, &fs_req, "stdout_file", UV_FS_O_CREAT | UV_FS_O_RDWR,
|
|
|
329 S_IRUSR | S_IWUSR, NULL);
|
|
|
330 ASSERT_NE(r, -1);
|
|
|
331 uv_fs_req_cleanup(&fs_req);
|
|
|
332
|
|
|
333 file = r;
|
|
|
334
|
|
|
335 options.stdio = stdio;
|
|
|
336 options.stdio[0].flags = UV_IGNORE;
|
|
|
337 options.stdio[1].flags = UV_INHERIT_FD;
|
|
|
338 options.stdio[1].data.fd = file;
|
|
|
339 options.stdio_count = 2;
|
|
|
340
|
|
|
341 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
342 ASSERT_OK(r);
|
|
|
343
|
|
|
344 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
345 ASSERT_OK(r);
|
|
|
346
|
|
|
347 ASSERT_EQ(1, exit_cb_called);
|
|
|
348 ASSERT_EQ(1, close_cb_called);
|
|
|
349
|
|
|
350 buf = uv_buf_init(output, sizeof(output));
|
|
|
351 r = uv_fs_read(NULL, &fs_req, file, &buf, 1, 0, NULL);
|
|
|
352 ASSERT_EQ(12, r);
|
|
|
353 uv_fs_req_cleanup(&fs_req);
|
|
|
354
|
|
|
355 r = uv_fs_close(NULL, &fs_req, file, NULL);
|
|
|
356 ASSERT_OK(r);
|
|
|
357 uv_fs_req_cleanup(&fs_req);
|
|
|
358
|
|
|
359 printf("output is: %s", output);
|
|
|
360 ASSERT_OK(strcmp("hello world\n", output));
|
|
|
361
|
|
|
362 /* Cleanup. */
|
|
|
363 unlink("stdout_file");
|
|
|
364
|
|
|
365 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
366 return 0;
|
|
|
367 }
|
|
|
368
|
|
|
369
|
|
|
370 TEST_IMPL(spawn_stdout_and_stderr_to_file) {
|
|
|
371 int r;
|
|
|
372 uv_file file;
|
|
|
373 uv_fs_t fs_req;
|
|
|
374 uv_stdio_container_t stdio[3];
|
|
|
375 uv_buf_t buf;
|
|
|
376
|
|
|
377 /* Setup. */
|
|
|
378 unlink("stdout_file");
|
|
|
379
|
|
|
380 init_process_options("spawn_helper6", exit_cb);
|
|
|
381
|
|
|
382 r = uv_fs_open(NULL, &fs_req, "stdout_file", UV_FS_O_CREAT | UV_FS_O_RDWR,
|
|
|
383 S_IRUSR | S_IWUSR, NULL);
|
|
|
384 ASSERT_NE(r, -1);
|
|
|
385 uv_fs_req_cleanup(&fs_req);
|
|
|
386
|
|
|
387 file = r;
|
|
|
388
|
|
|
389 options.stdio = stdio;
|
|
|
390 options.stdio[0].flags = UV_IGNORE;
|
|
|
391 options.stdio[1].flags = UV_INHERIT_FD;
|
|
|
392 options.stdio[1].data.fd = file;
|
|
|
393 options.stdio[2].flags = UV_INHERIT_FD;
|
|
|
394 options.stdio[2].data.fd = file;
|
|
|
395 options.stdio_count = 3;
|
|
|
396
|
|
|
397 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
398 ASSERT_OK(r);
|
|
|
399
|
|
|
400 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
401 ASSERT_OK(r);
|
|
|
402
|
|
|
403 ASSERT_EQ(1, exit_cb_called);
|
|
|
404 ASSERT_EQ(1, close_cb_called);
|
|
|
405
|
|
|
406 buf = uv_buf_init(output, sizeof(output));
|
|
|
407 r = uv_fs_read(NULL, &fs_req, file, &buf, 1, 0, NULL);
|
|
|
408 ASSERT_EQ(27, r);
|
|
|
409 uv_fs_req_cleanup(&fs_req);
|
|
|
410
|
|
|
411 r = uv_fs_close(NULL, &fs_req, file, NULL);
|
|
|
412 ASSERT_OK(r);
|
|
|
413 uv_fs_req_cleanup(&fs_req);
|
|
|
414
|
|
|
415 printf("output is: %s", output);
|
|
|
416 ASSERT_OK(strcmp("hello world\nhello errworld\n", output));
|
|
|
417
|
|
|
418 /* Cleanup. */
|
|
|
419 unlink("stdout_file");
|
|
|
420
|
|
|
421 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
422 return 0;
|
|
|
423 }
|
|
|
424
|
|
|
425
|
|
|
426 TEST_IMPL(spawn_stdout_and_stderr_to_file2) {
|
|
|
427 #ifndef _WIN32
|
|
|
428 int r;
|
|
|
429 uv_file file;
|
|
|
430 uv_fs_t fs_req;
|
|
|
431 uv_stdio_container_t stdio[3];
|
|
|
432 uv_buf_t buf;
|
|
|
433
|
|
|
434 /* Setup. */
|
|
|
435 unlink("stdout_file");
|
|
|
436
|
|
|
437 init_process_options("spawn_helper6", exit_cb);
|
|
|
438
|
|
|
439 /* Replace stderr with our file */
|
|
|
440 r = uv_fs_open(NULL,
|
|
|
441 &fs_req,
|
|
|
442 "stdout_file",
|
|
|
443 O_CREAT | O_RDWR,
|
|
|
444 S_IRUSR | S_IWUSR,
|
|
|
445 NULL);
|
|
|
446 ASSERT_NE(r, -1);
|
|
|
447 uv_fs_req_cleanup(&fs_req);
|
|
|
448 file = dup2(r, STDERR_FILENO);
|
|
|
449 ASSERT_NE(file, -1);
|
|
|
450
|
|
|
451 options.stdio = stdio;
|
|
|
452 options.stdio[0].flags = UV_IGNORE;
|
|
|
453 options.stdio[1].flags = UV_INHERIT_FD;
|
|
|
454 options.stdio[1].data.fd = file;
|
|
|
455 options.stdio[2].flags = UV_INHERIT_FD;
|
|
|
456 options.stdio[2].data.fd = file;
|
|
|
457 options.stdio_count = 3;
|
|
|
458
|
|
|
459 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
460 ASSERT_OK(r);
|
|
|
461
|
|
|
462 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
463 ASSERT_OK(r);
|
|
|
464
|
|
|
465 ASSERT_EQ(1, exit_cb_called);
|
|
|
466 ASSERT_EQ(1, close_cb_called);
|
|
|
467
|
|
|
468 buf = uv_buf_init(output, sizeof(output));
|
|
|
469 r = uv_fs_read(NULL, &fs_req, file, &buf, 1, 0, NULL);
|
|
|
470 ASSERT_EQ(27, r);
|
|
|
471 uv_fs_req_cleanup(&fs_req);
|
|
|
472
|
|
|
473 r = uv_fs_close(NULL, &fs_req, file, NULL);
|
|
|
474 ASSERT_OK(r);
|
|
|
475 uv_fs_req_cleanup(&fs_req);
|
|
|
476
|
|
|
477 printf("output is: %s", output);
|
|
|
478 ASSERT_OK(strcmp("hello world\nhello errworld\n", output));
|
|
|
479
|
|
|
480 /* Cleanup. */
|
|
|
481 unlink("stdout_file");
|
|
|
482
|
|
|
483 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
484 return 0;
|
|
|
485 #else
|
|
|
486 RETURN_SKIP("Unix only test");
|
|
|
487 #endif
|
|
|
488 }
|
|
|
489
|
|
|
490
|
|
|
491 TEST_IMPL(spawn_stdout_and_stderr_to_file_swap) {
|
|
|
492 #ifndef _WIN32
|
|
|
493 int r;
|
|
|
494 uv_file stdout_file;
|
|
|
495 uv_file stderr_file;
|
|
|
496 uv_fs_t fs_req;
|
|
|
497 uv_stdio_container_t stdio[3];
|
|
|
498 uv_buf_t buf;
|
|
|
499
|
|
|
500 /* Setup. */
|
|
|
501 unlink("stdout_file");
|
|
|
502 unlink("stderr_file");
|
|
|
503
|
|
|
504 init_process_options("spawn_helper6", exit_cb);
|
|
|
505
|
|
|
506 /* open 'stdout_file' and replace STDOUT_FILENO with it */
|
|
|
507 r = uv_fs_open(NULL,
|
|
|
508 &fs_req,
|
|
|
509 "stdout_file",
|
|
|
510 O_CREAT | O_RDWR,
|
|
|
511 S_IRUSR | S_IWUSR,
|
|
|
512 NULL);
|
|
|
513 ASSERT_NE(r, -1);
|
|
|
514 uv_fs_req_cleanup(&fs_req);
|
|
|
515 stdout_file = dup2(r, STDOUT_FILENO);
|
|
|
516 ASSERT_NE(stdout_file, -1);
|
|
|
517
|
|
|
518 /* open 'stderr_file' and replace STDERR_FILENO with it */
|
|
|
519 r = uv_fs_open(NULL, &fs_req, "stderr_file", O_CREAT | O_RDWR,
|
|
|
520 S_IRUSR | S_IWUSR, NULL);
|
|
|
521 ASSERT_NE(r, -1);
|
|
|
522 uv_fs_req_cleanup(&fs_req);
|
|
|
523 stderr_file = dup2(r, STDERR_FILENO);
|
|
|
524 ASSERT_NE(stderr_file, -1);
|
|
|
525
|
|
|
526 /* now we're going to swap them: the child process' stdout will be our
|
|
|
527 * stderr_file and vice versa */
|
|
|
528 options.stdio = stdio;
|
|
|
529 options.stdio[0].flags = UV_IGNORE;
|
|
|
530 options.stdio[1].flags = UV_INHERIT_FD;
|
|
|
531 options.stdio[1].data.fd = stderr_file;
|
|
|
532 options.stdio[2].flags = UV_INHERIT_FD;
|
|
|
533 options.stdio[2].data.fd = stdout_file;
|
|
|
534 options.stdio_count = 3;
|
|
|
535
|
|
|
536 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
537 ASSERT_OK(r);
|
|
|
538
|
|
|
539 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
540 ASSERT_OK(r);
|
|
|
541
|
|
|
542 ASSERT_EQ(1, exit_cb_called);
|
|
|
543 ASSERT_EQ(1, close_cb_called);
|
|
|
544
|
|
|
545 buf = uv_buf_init(output, sizeof(output));
|
|
|
546
|
|
|
547 /* check the content of stdout_file */
|
|
|
548 r = uv_fs_read(NULL, &fs_req, stdout_file, &buf, 1, 0, NULL);
|
|
|
549 ASSERT_GE(r, 15);
|
|
|
550 uv_fs_req_cleanup(&fs_req);
|
|
|
551
|
|
|
552 r = uv_fs_close(NULL, &fs_req, stdout_file, NULL);
|
|
|
553 ASSERT_OK(r);
|
|
|
554 uv_fs_req_cleanup(&fs_req);
|
|
|
555
|
|
|
556 printf("output is: %s", output);
|
|
|
557 ASSERT_OK(strncmp("hello errworld\n", output, 15));
|
|
|
558
|
|
|
559 /* check the content of stderr_file */
|
|
|
560 r = uv_fs_read(NULL, &fs_req, stderr_file, &buf, 1, 0, NULL);
|
|
|
561 ASSERT_GE(r, 12);
|
|
|
562 uv_fs_req_cleanup(&fs_req);
|
|
|
563
|
|
|
564 r = uv_fs_close(NULL, &fs_req, stderr_file, NULL);
|
|
|
565 ASSERT_OK(r);
|
|
|
566 uv_fs_req_cleanup(&fs_req);
|
|
|
567
|
|
|
568 printf("output is: %s", output);
|
|
|
569 ASSERT_OK(strncmp("hello world\n", output, 12));
|
|
|
570
|
|
|
571 /* Cleanup. */
|
|
|
572 unlink("stdout_file");
|
|
|
573 unlink("stderr_file");
|
|
|
574
|
|
|
575 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
576 return 0;
|
|
|
577 #else
|
|
|
578 RETURN_SKIP("Unix only test");
|
|
|
579 #endif
|
|
|
580 }
|
|
|
581
|
|
|
582
|
|
|
583 TEST_IMPL(spawn_stdin) {
|
|
|
584 int r;
|
|
|
585 uv_pipe_t out;
|
|
|
586 uv_pipe_t in;
|
|
|
587 uv_write_t write_req;
|
|
|
588 uv_buf_t buf;
|
|
|
589 uv_stdio_container_t stdio[2];
|
|
|
590 char buffer[] = "hello-from-spawn_stdin";
|
|
|
591
|
|
|
592 init_process_options("spawn_helper3", exit_cb);
|
|
|
593
|
|
|
594 uv_pipe_init(uv_default_loop(), &out, 0);
|
|
|
595 uv_pipe_init(uv_default_loop(), &in, 0);
|
|
|
596 options.stdio = stdio;
|
|
|
597 options.stdio[0].flags = UV_CREATE_PIPE | UV_READABLE_PIPE;
|
|
|
598 options.stdio[0].data.stream = (uv_stream_t*) ∈
|
|
|
599 options.stdio[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
|
|
|
600 options.stdio[1].data.stream = (uv_stream_t*) &out;
|
|
|
601 options.stdio_count = 2;
|
|
|
602
|
|
|
603 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
604 ASSERT_OK(r);
|
|
|
605
|
|
|
606 buf.base = buffer;
|
|
|
607 buf.len = sizeof(buffer);
|
|
|
608 r = uv_write(&write_req, (uv_stream_t*) &in, &buf, 1, write_cb);
|
|
|
609 ASSERT_OK(r);
|
|
|
610
|
|
|
611 r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
|
|
|
612 ASSERT_OK(r);
|
|
|
613
|
|
|
614 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
615 ASSERT_OK(r);
|
|
|
616
|
|
|
617 ASSERT_EQ(1, exit_cb_called);
|
|
|
618 ASSERT_EQ(3, close_cb_called); /* Once for process twice for the pipe. */
|
|
|
619 ASSERT_OK(strcmp(buffer, output));
|
|
|
620
|
|
|
621 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
622 return 0;
|
|
|
623 }
|
|
|
624
|
|
|
625
|
|
|
626 TEST_IMPL(spawn_stdio_greater_than_3) {
|
|
|
627 int r;
|
|
|
628 uv_pipe_t pipe;
|
|
|
629 uv_stdio_container_t stdio[4];
|
|
|
630
|
|
|
631 init_process_options("spawn_helper5", exit_cb);
|
|
|
632
|
|
|
633 uv_pipe_init(uv_default_loop(), &pipe, 0);
|
|
|
634 options.stdio = stdio;
|
|
|
635 options.stdio[0].flags = UV_IGNORE;
|
|
|
636 options.stdio[1].flags = UV_IGNORE;
|
|
|
637 options.stdio[2].flags = UV_IGNORE;
|
|
|
638 options.stdio[3].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
|
|
|
639 options.stdio[3].data.stream = (uv_stream_t*) &pipe;
|
|
|
640 options.stdio_count = 4;
|
|
|
641
|
|
|
642 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
643 ASSERT_OK(r);
|
|
|
644
|
|
|
645 r = uv_read_start((uv_stream_t*) &pipe, on_alloc, on_read);
|
|
|
646 ASSERT_OK(r);
|
|
|
647
|
|
|
648 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
649 ASSERT_OK(r);
|
|
|
650
|
|
|
651 ASSERT_EQ(1, exit_cb_called);
|
|
|
652 ASSERT_EQ(2, close_cb_called); /* Once for process once for the pipe. */
|
|
|
653 printf("output from stdio[3] is: %s", output);
|
|
|
654 ASSERT_OK(strcmp("fourth stdio!\n", output));
|
|
|
655
|
|
|
656 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
657 return 0;
|
|
|
658 }
|
|
|
659
|
|
|
660
|
|
|
661 int spawn_tcp_server_helper(void) {
|
|
|
662 uv_tcp_t tcp;
|
|
|
663 uv_os_sock_t handle;
|
|
|
664 int r;
|
|
|
665
|
|
|
666 r = uv_tcp_init(uv_default_loop(), &tcp);
|
|
|
667 ASSERT_OK(r);
|
|
|
668
|
|
|
669 #ifdef _WIN32
|
|
|
670 handle = _get_osfhandle(3);
|
|
|
671 #else
|
|
|
672 handle = 3;
|
|
|
673 #endif
|
|
|
674 r = uv_tcp_open(&tcp, handle);
|
|
|
675 ASSERT_OK(r);
|
|
|
676
|
|
|
677 /* Make sure that we can listen on a socket that was
|
|
|
678 * passed down from the parent process
|
|
|
679 */
|
|
|
680 r = uv_listen((uv_stream_t*) &tcp, SOMAXCONN, NULL);
|
|
|
681 ASSERT_OK(r);
|
|
|
682
|
|
|
683 return 1;
|
|
|
684 }
|
|
|
685
|
|
|
686
|
|
|
687 TEST_IMPL(spawn_tcp_server) {
|
|
|
688 uv_stdio_container_t stdio[4];
|
|
|
689 struct sockaddr_in addr;
|
|
|
690 int fd;
|
|
|
691 int r;
|
|
|
692 #ifdef _WIN32
|
|
|
693 uv_os_fd_t handle;
|
|
|
694 #endif
|
|
|
695
|
|
|
696 init_process_options("spawn_tcp_server_helper", exit_cb);
|
|
|
697
|
|
|
698 ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
|
|
|
699
|
|
|
700 fd = -1;
|
|
|
701 r = uv_tcp_init_ex(uv_default_loop(), &tcp_server, AF_INET);
|
|
|
702 ASSERT_OK(r);
|
|
|
703 r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0);
|
|
|
704 ASSERT_OK(r);
|
|
|
705 #ifdef _WIN32
|
|
|
706 r = uv_fileno((uv_handle_t*) &tcp_server, &handle);
|
|
|
707 fd = _open_osfhandle((intptr_t) handle, 0);
|
|
|
708 #else
|
|
|
709 r = uv_fileno((uv_handle_t*) &tcp_server, &fd);
|
|
|
710 #endif
|
|
|
711 ASSERT_OK(r);
|
|
|
712 ASSERT_GT(fd, 0);
|
|
|
713
|
|
|
714 options.stdio = stdio;
|
|
|
715 options.stdio[0].flags = UV_INHERIT_FD;
|
|
|
716 options.stdio[0].data.fd = 0;
|
|
|
717 options.stdio[1].flags = UV_INHERIT_FD;
|
|
|
718 options.stdio[1].data.fd = 1;
|
|
|
719 options.stdio[2].flags = UV_INHERIT_FD;
|
|
|
720 options.stdio[2].data.fd = 2;
|
|
|
721 options.stdio[3].flags = UV_INHERIT_FD;
|
|
|
722 options.stdio[3].data.fd = fd;
|
|
|
723 options.stdio_count = 4;
|
|
|
724
|
|
|
725 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
726 ASSERT_OK(r);
|
|
|
727
|
|
|
728 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
729 ASSERT_OK(r);
|
|
|
730
|
|
|
731 ASSERT_EQ(1, exit_cb_called);
|
|
|
732 ASSERT_EQ(1, close_cb_called);
|
|
|
733
|
|
|
734 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
735 return 0;
|
|
|
736 }
|
|
|
737
|
|
|
738
|
|
|
739 TEST_IMPL(spawn_ignored_stdio) {
|
|
|
740 int r;
|
|
|
741
|
|
|
742 init_process_options("spawn_helper6", exit_cb);
|
|
|
743
|
|
|
744 options.stdio = NULL;
|
|
|
745 options.stdio_count = 0;
|
|
|
746
|
|
|
747 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
748 ASSERT_OK(r);
|
|
|
749
|
|
|
750 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
751 ASSERT_OK(r);
|
|
|
752
|
|
|
753 ASSERT_EQ(1, exit_cb_called);
|
|
|
754 ASSERT_EQ(1, close_cb_called);
|
|
|
755
|
|
|
756 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
757 return 0;
|
|
|
758 }
|
|
|
759
|
|
|
760
|
|
|
761 TEST_IMPL(spawn_and_kill) {
|
|
|
762 int r;
|
|
|
763
|
|
|
764 init_process_options("spawn_helper4", kill_cb);
|
|
|
765
|
|
|
766 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
767 ASSERT_OK(r);
|
|
|
768
|
|
|
769 r = uv_timer_init(uv_default_loop(), &timer);
|
|
|
770 ASSERT_OK(r);
|
|
|
771
|
|
|
772 r = uv_timer_start(&timer, timer_cb, 500, 0);
|
|
|
773 ASSERT_OK(r);
|
|
|
774
|
|
|
775 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
776 ASSERT_OK(r);
|
|
|
777
|
|
|
778 ASSERT_EQ(1, exit_cb_called);
|
|
|
779 ASSERT_EQ(2, close_cb_called); /* Once for process and once for timer. */
|
|
|
780
|
|
|
781 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
782 return 0;
|
|
|
783 }
|
|
|
784
|
|
|
785
|
|
|
786 TEST_IMPL(spawn_preserve_env) {
|
|
|
787 int r;
|
|
|
788 uv_pipe_t out;
|
|
|
789 uv_stdio_container_t stdio[2];
|
|
|
790
|
|
|
791 init_process_options("spawn_helper7", exit_cb);
|
|
|
792
|
|
|
793 uv_pipe_init(uv_default_loop(), &out, 0);
|
|
|
794 options.stdio = stdio;
|
|
|
795 options.stdio[0].flags = UV_IGNORE;
|
|
|
796 options.stdio[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
|
|
|
797 options.stdio[1].data.stream = (uv_stream_t*) &out;
|
|
|
798 options.stdio_count = 2;
|
|
|
799
|
|
|
800 r = putenv("ENV_TEST=testval");
|
|
|
801 ASSERT_OK(r);
|
|
|
802
|
|
|
803 /* Explicitly set options.env to NULL to test for env clobbering. */
|
|
|
804 options.env = NULL;
|
|
|
805
|
|
|
806 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
807 ASSERT_OK(r);
|
|
|
808
|
|
|
809 r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
|
|
|
810 ASSERT_OK(r);
|
|
|
811
|
|
|
812 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
813 ASSERT_OK(r);
|
|
|
814
|
|
|
815 ASSERT_EQ(1, exit_cb_called);
|
|
|
816 ASSERT_EQ(2, close_cb_called);
|
|
|
817
|
|
|
818 printf("output is: %s", output);
|
|
|
819 ASSERT_OK(strcmp("testval", output));
|
|
|
820
|
|
|
821 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
822 return 0;
|
|
|
823 }
|
|
|
824
|
|
|
825
|
|
|
826 TEST_IMPL(spawn_detached) {
|
|
|
827 int r;
|
|
|
828
|
|
|
829 init_process_options("spawn_helper4", detach_failure_cb);
|
|
|
830
|
|
|
831 options.flags |= UV_PROCESS_DETACHED;
|
|
|
832
|
|
|
833 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
834 ASSERT_OK(r);
|
|
|
835
|
|
|
836 uv_unref((uv_handle_t*) &process);
|
|
|
837
|
|
|
838 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
839 ASSERT_OK(r);
|
|
|
840
|
|
|
841 ASSERT_OK(exit_cb_called);
|
|
|
842
|
|
|
843 ASSERT_EQ(process.pid, uv_process_get_pid(&process));
|
|
|
844
|
|
|
845 r = uv_kill(process.pid, 0);
|
|
|
846 ASSERT_OK(r);
|
|
|
847
|
|
|
848 r = uv_kill(process.pid, SIGTERM);
|
|
|
849 ASSERT_OK(r);
|
|
|
850
|
|
|
851 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
852 return 0;
|
|
|
853 }
|
|
|
854
|
|
|
855 TEST_IMPL(spawn_and_kill_with_std) {
|
|
|
856 int r;
|
|
|
857 uv_pipe_t in, out, err;
|
|
|
858 uv_write_t write;
|
|
|
859 char message[] = "Nancy's joining me because the message this evening is "
|
|
|
860 "not my message but ours.";
|
|
|
861 uv_buf_t buf;
|
|
|
862 uv_stdio_container_t stdio[3];
|
|
|
863
|
|
|
864 init_process_options("spawn_helper4", kill_cb);
|
|
|
865
|
|
|
866 r = uv_pipe_init(uv_default_loop(), &in, 0);
|
|
|
867 ASSERT_OK(r);
|
|
|
868
|
|
|
869 r = uv_pipe_init(uv_default_loop(), &out, 0);
|
|
|
870 ASSERT_OK(r);
|
|
|
871
|
|
|
872 r = uv_pipe_init(uv_default_loop(), &err, 0);
|
|
|
873 ASSERT_OK(r);
|
|
|
874
|
|
|
875 options.stdio = stdio;
|
|
|
876 options.stdio[0].flags = UV_CREATE_PIPE | UV_READABLE_PIPE;
|
|
|
877 options.stdio[0].data.stream = (uv_stream_t*) ∈
|
|
|
878 options.stdio[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
|
|
|
879 options.stdio[1].data.stream = (uv_stream_t*) &out;
|
|
|
880 options.stdio[2].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
|
|
|
881 options.stdio[2].data.stream = (uv_stream_t*) &err;
|
|
|
882 options.stdio_count = 3;
|
|
|
883
|
|
|
884 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
885 ASSERT_OK(r);
|
|
|
886
|
|
|
887 buf = uv_buf_init(message, sizeof message);
|
|
|
888 r = uv_write(&write, (uv_stream_t*) &in, &buf, 1, write_cb);
|
|
|
889 ASSERT_OK(r);
|
|
|
890
|
|
|
891 r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
|
|
|
892 ASSERT_OK(r);
|
|
|
893
|
|
|
894 r = uv_read_start((uv_stream_t*) &err, on_alloc, on_read);
|
|
|
895 ASSERT_OK(r);
|
|
|
896
|
|
|
897 r = uv_timer_init(uv_default_loop(), &timer);
|
|
|
898 ASSERT_OK(r);
|
|
|
899
|
|
|
900 r = uv_timer_start(&timer, timer_cb, 500, 0);
|
|
|
901 ASSERT_OK(r);
|
|
|
902
|
|
|
903 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
904 ASSERT_OK(r);
|
|
|
905
|
|
|
906 ASSERT_EQ(1, exit_cb_called);
|
|
|
907 ASSERT_EQ(5, close_cb_called); /* process x 1, timer x 1, stdio x 3. */
|
|
|
908
|
|
|
909 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
910 return 0;
|
|
|
911 }
|
|
|
912
|
|
|
913
|
|
|
914 TEST_IMPL(spawn_and_ping) {
|
|
|
915 uv_write_t write_req;
|
|
|
916 uv_pipe_t in, out;
|
|
|
917 uv_buf_t buf;
|
|
|
918 uv_stdio_container_t stdio[2];
|
|
|
919 int r;
|
|
|
920
|
|
|
921 init_process_options("spawn_helper3", exit_cb);
|
|
|
922 buf = uv_buf_init("TEST", 4);
|
|
|
923
|
|
|
924 uv_pipe_init(uv_default_loop(), &out, 0);
|
|
|
925 uv_pipe_init(uv_default_loop(), &in, 0);
|
|
|
926 options.stdio = stdio;
|
|
|
927 options.stdio[0].flags = UV_CREATE_PIPE | UV_READABLE_PIPE;
|
|
|
928 options.stdio[0].data.stream = (uv_stream_t*) ∈
|
|
|
929 options.stdio[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
|
|
|
930 options.stdio[1].data.stream = (uv_stream_t*) &out;
|
|
|
931 options.stdio_count = 2;
|
|
|
932
|
|
|
933 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
934 ASSERT_OK(r);
|
|
|
935
|
|
|
936 /* Sending signum == 0 should check if the
|
|
|
937 * child process is still alive, not kill it.
|
|
|
938 */
|
|
|
939 r = uv_process_kill(&process, 0);
|
|
|
940 ASSERT_OK(r);
|
|
|
941
|
|
|
942 r = uv_write(&write_req, (uv_stream_t*) &in, &buf, 1, write_cb);
|
|
|
943 ASSERT_OK(r);
|
|
|
944
|
|
|
945 r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
|
|
|
946 ASSERT_OK(r);
|
|
|
947
|
|
|
948 ASSERT_OK(exit_cb_called);
|
|
|
949
|
|
|
950 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
951 ASSERT_OK(r);
|
|
|
952
|
|
|
953 ASSERT_EQ(1, exit_cb_called);
|
|
|
954 ASSERT_OK(strcmp(output, "TEST"));
|
|
|
955
|
|
|
956 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
957 return 0;
|
|
|
958 }
|
|
|
959
|
|
|
960
|
|
|
961 TEST_IMPL(spawn_same_stdout_stderr) {
|
|
|
962 uv_write_t write_req;
|
|
|
963 uv_pipe_t in, out;
|
|
|
964 uv_buf_t buf;
|
|
|
965 uv_stdio_container_t stdio[3];
|
|
|
966 int r;
|
|
|
967
|
|
|
968 init_process_options("spawn_helper3", exit_cb);
|
|
|
969 buf = uv_buf_init("TEST", 4);
|
|
|
970
|
|
|
971 uv_pipe_init(uv_default_loop(), &out, 0);
|
|
|
972 uv_pipe_init(uv_default_loop(), &in, 0);
|
|
|
973 options.stdio = stdio;
|
|
|
974 options.stdio[0].flags = UV_CREATE_PIPE | UV_READABLE_PIPE;
|
|
|
975 options.stdio[0].data.stream = (uv_stream_t*) ∈
|
|
|
976 options.stdio[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
|
|
|
977 options.stdio[1].data.stream = (uv_stream_t*) &out;
|
|
|
978 options.stdio_count = 2;
|
|
|
979
|
|
|
980 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
981 ASSERT_OK(r);
|
|
|
982
|
|
|
983 /* Sending signum == 0 should check if the
|
|
|
984 * child process is still alive, not kill it.
|
|
|
985 */
|
|
|
986 r = uv_process_kill(&process, 0);
|
|
|
987 ASSERT_OK(r);
|
|
|
988
|
|
|
989 r = uv_write(&write_req, (uv_stream_t*) &in, &buf, 1, write_cb);
|
|
|
990 ASSERT_OK(r);
|
|
|
991
|
|
|
992 r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
|
|
|
993 ASSERT_OK(r);
|
|
|
994
|
|
|
995 ASSERT_OK(exit_cb_called);
|
|
|
996
|
|
|
997 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
998 ASSERT_OK(r);
|
|
|
999
|
|
|
1000 ASSERT_EQ(1, exit_cb_called);
|
|
|
1001 ASSERT_OK(strcmp(output, "TEST"));
|
|
|
1002
|
|
|
1003 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1004 return 0;
|
|
|
1005 }
|
|
|
1006
|
|
|
1007
|
|
|
1008 TEST_IMPL(spawn_closed_process_io) {
|
|
|
1009 uv_pipe_t in;
|
|
|
1010 uv_write_t write_req;
|
|
|
1011 uv_buf_t buf;
|
|
|
1012 uv_stdio_container_t stdio[2];
|
|
|
1013 static char buffer[] = "hello-from-spawn_stdin\n";
|
|
|
1014
|
|
|
1015 init_process_options("spawn_helper3", exit_cb);
|
|
|
1016
|
|
|
1017 uv_pipe_init(uv_default_loop(), &in, 0);
|
|
|
1018 options.stdio = stdio;
|
|
|
1019 options.stdio[0].flags = UV_CREATE_PIPE | UV_READABLE_PIPE;
|
|
|
1020 options.stdio[0].data.stream = (uv_stream_t*) ∈
|
|
|
1021 options.stdio_count = 1;
|
|
|
1022
|
|
|
1023 close(0); /* Close process stdin. */
|
|
|
1024
|
|
|
1025 ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options));
|
|
|
1026
|
|
|
1027 buf = uv_buf_init(buffer, sizeof(buffer));
|
|
|
1028 ASSERT_OK(uv_write(&write_req, (uv_stream_t*) &in, &buf, 1, write_cb));
|
|
|
1029
|
|
|
1030 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
1031
|
|
|
1032 ASSERT_EQ(1, exit_cb_called);
|
|
|
1033 ASSERT_EQ(2, close_cb_called); /* process, child stdin */
|
|
|
1034
|
|
|
1035 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1036 return 0;
|
|
|
1037 }
|
|
|
1038
|
|
|
1039
|
|
|
1040 TEST_IMPL(kill) {
|
|
|
1041 int r;
|
|
|
1042
|
|
|
1043 #ifdef _WIN32
|
|
|
1044 no_term_signal = 1;
|
|
|
1045 #endif
|
|
|
1046
|
|
|
1047 init_process_options("spawn_helper4", kill_cb);
|
|
|
1048
|
|
|
1049 /* Verify that uv_spawn() resets the signal disposition. */
|
|
|
1050 #ifndef _WIN32
|
|
|
1051 {
|
|
|
1052 sigset_t set;
|
|
|
1053 sigemptyset(&set);
|
|
|
1054 sigaddset(&set, SIGTERM);
|
|
|
1055 ASSERT_OK(pthread_sigmask(SIG_BLOCK, &set, NULL));
|
|
|
1056 }
|
|
|
1057 ASSERT_PTR_NE(SIG_ERR, signal(SIGTERM, SIG_IGN));
|
|
|
1058 #endif
|
|
|
1059
|
|
|
1060 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
1061 ASSERT_OK(r);
|
|
|
1062
|
|
|
1063 #ifndef _WIN32
|
|
|
1064 {
|
|
|
1065 sigset_t set;
|
|
|
1066 sigemptyset(&set);
|
|
|
1067 sigaddset(&set, SIGTERM);
|
|
|
1068 ASSERT_OK(pthread_sigmask(SIG_UNBLOCK, &set, NULL));
|
|
|
1069 }
|
|
|
1070 ASSERT_PTR_NE(SIG_ERR, signal(SIGTERM, SIG_DFL));
|
|
|
1071 #endif
|
|
|
1072
|
|
|
1073 /* Sending signum == 0 should check if the
|
|
|
1074 * child process is still alive, not kill it.
|
|
|
1075 */
|
|
|
1076 r = uv_kill(process.pid, 0);
|
|
|
1077 ASSERT_OK(r);
|
|
|
1078
|
|
|
1079 /* Kill the process. */
|
|
|
1080 r = uv_kill(process.pid, SIGTERM);
|
|
|
1081 ASSERT_OK(r);
|
|
|
1082
|
|
|
1083 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
1084 ASSERT_OK(r);
|
|
|
1085
|
|
|
1086 ASSERT_EQ(1, exit_cb_called);
|
|
|
1087 ASSERT_EQ(1, close_cb_called);
|
|
|
1088
|
|
|
1089 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1090 return 0;
|
|
|
1091 }
|
|
|
1092
|
|
|
1093
|
|
|
1094 #ifdef _WIN32
|
|
|
1095 TEST_IMPL(spawn_detect_pipe_name_collisions_on_windows) {
|
|
|
1096 int r;
|
|
|
1097 uv_pipe_t out;
|
|
|
1098 char name[64];
|
|
|
1099 HANDLE pipe_handle;
|
|
|
1100 uv_stdio_container_t stdio[2];
|
|
|
1101
|
|
|
1102 init_process_options("spawn_helper2", exit_cb);
|
|
|
1103
|
|
|
1104 uv_pipe_init(uv_default_loop(), &out, 0);
|
|
|
1105 options.stdio = stdio;
|
|
|
1106 options.stdio[0].flags = UV_IGNORE;
|
|
|
1107 options.stdio[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
|
|
|
1108 options.stdio[1].data.stream = (uv_stream_t*) &out;
|
|
|
1109 options.stdio_count = 2;
|
|
|
1110
|
|
|
1111 /* Create a pipe that'll cause a collision. */
|
|
|
1112 snprintf(name,
|
|
|
1113 sizeof(name),
|
|
|
1114 "\\\\.\\pipe\\uv\\%p-%lu",
|
|
|
1115 &out,
|
|
|
1116 GetCurrentProcessId());
|
|
|
1117 pipe_handle = CreateNamedPipeA(name,
|
|
|
1118 PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
|
|
|
1119 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
|
|
|
1120 10,
|
|
|
1121 65536,
|
|
|
1122 65536,
|
|
|
1123 0,
|
|
|
1124 NULL);
|
|
|
1125 ASSERT_PTR_NE(pipe_handle, INVALID_HANDLE_VALUE);
|
|
|
1126
|
|
|
1127 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
1128 ASSERT_OK(r);
|
|
|
1129
|
|
|
1130 r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
|
|
|
1131 ASSERT_OK(r);
|
|
|
1132
|
|
|
1133 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
1134 ASSERT_OK(r);
|
|
|
1135
|
|
|
1136 ASSERT_EQ(1, exit_cb_called);
|
|
|
1137 ASSERT_EQ(2, close_cb_called); /* Once for process once for the pipe. */
|
|
|
1138 printf("output is: %s", output);
|
|
|
1139 ASSERT_OK(strcmp("hello world\n", output));
|
|
|
1140
|
|
|
1141 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1142 return 0;
|
|
|
1143 }
|
|
|
1144
|
|
|
1145
|
|
|
1146 #if !defined(USING_UV_SHARED)
|
|
|
1147 int make_program_args(char** args, int verbatim_arguments, WCHAR** dst_ptr);
|
|
|
1148 WCHAR* quote_cmd_arg(const WCHAR *source, WCHAR *target);
|
|
|
1149
|
|
|
1150 TEST_IMPL(argument_escaping) {
|
|
|
1151 const WCHAR* test_str[] = {
|
|
|
1152 L"",
|
|
|
1153 L"HelloWorld",
|
|
|
1154 L"Hello World",
|
|
|
1155 L"Hello\"World",
|
|
|
1156 L"Hello World\\",
|
|
|
1157 L"Hello\\\"World",
|
|
|
1158 L"Hello\\World",
|
|
|
1159 L"Hello\\\\World",
|
|
|
1160 L"Hello World\\",
|
|
|
1161 L"c:\\path\\to\\node.exe --eval \"require('c:\\\\path\\\\to\\\\test.js')\""
|
|
|
1162 };
|
|
|
1163 const int count = sizeof(test_str) / sizeof(*test_str);
|
|
|
1164 WCHAR** test_output;
|
|
|
1165 WCHAR* command_line;
|
|
|
1166 WCHAR** cracked;
|
|
|
1167 size_t total_size = 0;
|
|
|
1168 int i;
|
|
|
1169 int num_args;
|
|
|
1170 int result;
|
|
|
1171
|
|
|
1172 char* verbatim[] = {
|
|
|
1173 "cmd.exe",
|
|
|
1174 "/c",
|
|
|
1175 "c:\\path\\to\\node.exe --eval \"require('c:\\\\path\\\\to\\\\test.js')\"",
|
|
|
1176 NULL
|
|
|
1177 };
|
|
|
1178 WCHAR* verbatim_output;
|
|
|
1179 WCHAR* non_verbatim_output;
|
|
|
1180
|
|
|
1181 test_output = calloc(count, sizeof(WCHAR*));
|
|
|
1182 ASSERT_NOT_NULL(test_output);
|
|
|
1183 for (i = 0; i < count; ++i) {
|
|
|
1184 test_output[i] = calloc(2 * (wcslen(test_str[i]) + 2), sizeof(WCHAR));
|
|
|
1185 quote_cmd_arg(test_str[i], test_output[i]);
|
|
|
1186 wprintf(L"input : %s\n", test_str[i]);
|
|
|
1187 wprintf(L"output: %s\n", test_output[i]);
|
|
|
1188 total_size += wcslen(test_output[i]) + 1;
|
|
|
1189 }
|
|
|
1190 command_line = calloc(total_size + 1, sizeof(WCHAR));
|
|
|
1191 ASSERT_NOT_NULL(command_line);
|
|
|
1192 for (i = 0; i < count; ++i) {
|
|
|
1193 wcscat(command_line, test_output[i]);
|
|
|
1194 wcscat(command_line, L" ");
|
|
|
1195 }
|
|
|
1196 command_line[total_size - 1] = L'\0';
|
|
|
1197
|
|
|
1198 wprintf(L"command_line: %s\n", command_line);
|
|
|
1199
|
|
|
1200 cracked = CommandLineToArgvW(command_line, &num_args);
|
|
|
1201 for (i = 0; i < num_args; ++i) {
|
|
|
1202 wprintf(L"%d: %s\t%s\n", i, test_str[i], cracked[i]);
|
|
|
1203 ASSERT_OK(wcscmp(test_str[i], cracked[i]));
|
|
|
1204 }
|
|
|
1205
|
|
|
1206 LocalFree(cracked);
|
|
|
1207 for (i = 0; i < count; ++i) {
|
|
|
1208 free(test_output[i]);
|
|
|
1209 }
|
|
|
1210 free(test_output);
|
|
|
1211
|
|
|
1212 result = make_program_args(verbatim, 1, &verbatim_output);
|
|
|
1213 ASSERT_OK(result);
|
|
|
1214 result = make_program_args(verbatim, 0, &non_verbatim_output);
|
|
|
1215 ASSERT_OK(result);
|
|
|
1216
|
|
|
1217 wprintf(L" verbatim_output: %s\n", verbatim_output);
|
|
|
1218 wprintf(L"non_verbatim_output: %s\n", non_verbatim_output);
|
|
|
1219
|
|
|
1220 ASSERT_OK(wcscmp(verbatim_output,
|
|
|
1221 L"cmd.exe /c c:\\path\\to\\node.exe --eval "
|
|
|
1222 L"\"require('c:\\\\path\\\\to\\\\test.js')\""));
|
|
|
1223 ASSERT_OK(wcscmp(non_verbatim_output,
|
|
|
1224 L"cmd.exe /c \"c:\\path\\to\\node.exe --eval "
|
|
|
1225 L"\\\"require('c:\\\\path\\\\to\\\\test.js')\\\"\""));
|
|
|
1226
|
|
|
1227 free(verbatim_output);
|
|
|
1228 free(non_verbatim_output);
|
|
|
1229
|
|
|
1230 return 0;
|
|
|
1231 }
|
|
|
1232
|
|
|
1233 int make_program_env(char** env_block, WCHAR** dst_ptr);
|
|
|
1234
|
|
|
1235 TEST_IMPL(environment_creation) {
|
|
|
1236 size_t i;
|
|
|
1237 char* environment[] = {
|
|
|
1238 "FOO=BAR",
|
|
|
1239 "SYSTEM=ROOT", /* substring of a supplied var name */
|
|
|
1240 "SYSTEMROOTED=OMG", /* supplied var name is a substring */
|
|
|
1241 "TEMP=C:\\Temp",
|
|
|
1242 "INVALID",
|
|
|
1243 "BAZ=QUX",
|
|
|
1244 "B_Z=QUX",
|
|
|
1245 "B\xe2\x82\xacZ=QUX",
|
|
|
1246 "B\xf0\x90\x80\x82Z=QUX",
|
|
|
1247 "B\xef\xbd\xa1Z=QUX",
|
|
|
1248 "B\xf0\xa3\x91\x96Z=QUX",
|
|
|
1249 "BAZ", /* repeat, invalid variable */
|
|
|
1250 NULL
|
|
|
1251 };
|
|
|
1252 WCHAR* wenvironment[] = {
|
|
|
1253 L"BAZ=QUX",
|
|
|
1254 L"B_Z=QUX",
|
|
|
1255 L"B\x20acZ=QUX",
|
|
|
1256 L"B\xd800\xdc02Z=QUX",
|
|
|
1257 L"B\xd84d\xdc56Z=QUX",
|
|
|
1258 L"B\xff61Z=QUX",
|
|
|
1259 L"FOO=BAR",
|
|
|
1260 L"SYSTEM=ROOT", /* substring of a supplied var name */
|
|
|
1261 L"SYSTEMROOTED=OMG", /* supplied var name is a substring */
|
|
|
1262 L"TEMP=C:\\Temp",
|
|
|
1263 };
|
|
|
1264 WCHAR* from_env[] = {
|
|
|
1265 /* list should be kept in sync with list
|
|
|
1266 * in process.c, minus variables in wenvironment */
|
|
|
1267 L"HOMEDRIVE",
|
|
|
1268 L"HOMEPATH",
|
|
|
1269 L"LOGONSERVER",
|
|
|
1270 L"PATH",
|
|
|
1271 L"USERDOMAIN",
|
|
|
1272 L"USERNAME",
|
|
|
1273 L"USERPROFILE",
|
|
|
1274 L"SYSTEMDRIVE",
|
|
|
1275 L"SYSTEMROOT",
|
|
|
1276 L"WINDIR",
|
|
|
1277 /* test for behavior in the absence of a
|
|
|
1278 * required-environment variable: */
|
|
|
1279 L"ZTHIS_ENV_VARIABLE_DOES_NOT_EXIST",
|
|
|
1280 };
|
|
|
1281 int found_in_loc_env[ARRAY_SIZE(wenvironment)] = {0};
|
|
|
1282 int found_in_usr_env[ARRAY_SIZE(from_env)] = {0};
|
|
|
1283 WCHAR *expected[ARRAY_SIZE(from_env)];
|
|
|
1284 int result;
|
|
|
1285 WCHAR* str;
|
|
|
1286 WCHAR* prev;
|
|
|
1287 WCHAR* env;
|
|
|
1288
|
|
|
1289 for (i = 0; i < ARRAY_SIZE(from_env); i++) {
|
|
|
1290 /* copy expected additions to environment locally */
|
|
|
1291 size_t len = GetEnvironmentVariableW(from_env[i], NULL, 0);
|
|
|
1292 if (len == 0) {
|
|
|
1293 found_in_usr_env[i] = 1;
|
|
|
1294 str = malloc(1 * sizeof(WCHAR));
|
|
|
1295 *str = 0;
|
|
|
1296 expected[i] = str;
|
|
|
1297 } else {
|
|
|
1298 size_t name_len = wcslen(from_env[i]);
|
|
|
1299 str = malloc((name_len+1+len) * sizeof(WCHAR));
|
|
|
1300 wmemcpy(str, from_env[i], name_len);
|
|
|
1301 expected[i] = str;
|
|
|
1302 str += name_len;
|
|
|
1303 *str++ = L'=';
|
|
|
1304 GetEnvironmentVariableW(from_env[i], str, len);
|
|
|
1305 }
|
|
|
1306 }
|
|
|
1307
|
|
|
1308 result = make_program_env(environment, &env);
|
|
|
1309 ASSERT_OK(result);
|
|
|
1310
|
|
|
1311 for (str = env, prev = NULL; *str; prev = str, str += wcslen(str) + 1) {
|
|
|
1312 int found = 0;
|
|
|
1313 #if 0
|
|
|
1314 _cputws(str);
|
|
|
1315 putchar('\n');
|
|
|
1316 #endif
|
|
|
1317 for (i = 0; i < ARRAY_SIZE(wenvironment) && !found; i++) {
|
|
|
1318 if (!wcscmp(str, wenvironment[i])) {
|
|
|
1319 ASSERT(!found_in_loc_env[i]);
|
|
|
1320 found_in_loc_env[i] = 1;
|
|
|
1321 found = 1;
|
|
|
1322 }
|
|
|
1323 }
|
|
|
1324 for (i = 0; i < ARRAY_SIZE(expected) && !found; i++) {
|
|
|
1325 if (!wcscmp(str, expected[i])) {
|
|
|
1326 ASSERT(!found_in_usr_env[i]);
|
|
|
1327 found_in_usr_env[i] = 1;
|
|
|
1328 found = 1;
|
|
|
1329 }
|
|
|
1330 }
|
|
|
1331 if (prev) { /* verify sort order */
|
|
|
1332 ASSERT_EQ(1, CompareStringOrdinal(prev, -1, str, -1, TRUE));
|
|
|
1333 }
|
|
|
1334 ASSERT(found); /* verify that we expected this variable */
|
|
|
1335 }
|
|
|
1336
|
|
|
1337 /* verify that we found all expected variables */
|
|
|
1338 for (i = 0; i < ARRAY_SIZE(wenvironment); i++) {
|
|
|
1339 ASSERT(found_in_loc_env[i]);
|
|
|
1340 }
|
|
|
1341 for (i = 0; i < ARRAY_SIZE(expected); i++) {
|
|
|
1342 ASSERT(found_in_usr_env[i]);
|
|
|
1343 }
|
|
|
1344
|
|
|
1345 return 0;
|
|
|
1346 }
|
|
|
1347 #endif
|
|
|
1348
|
|
|
1349 /* Regression test for issue #909 */
|
|
|
1350 TEST_IMPL(spawn_with_an_odd_path) {
|
|
|
1351 int r;
|
|
|
1352
|
|
|
1353 char newpath[2048];
|
|
|
1354 char *path = getenv("PATH");
|
|
|
1355 ASSERT_NOT_NULL(path);
|
|
|
1356 snprintf(newpath, 2048, ";.;%s", path);
|
|
|
1357 SetEnvironmentVariable("PATH", newpath);
|
|
|
1358
|
|
|
1359 init_process_options("", exit_cb);
|
|
|
1360 options.file = options.args[0] = "program-that-had-better-not-exist";
|
|
|
1361 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
1362 ASSERT(r == UV_ENOENT || r == UV_EACCES);
|
|
|
1363 ASSERT_OK(uv_is_active((uv_handle_t*) &process));
|
|
|
1364 uv_close((uv_handle_t*) &process, NULL);
|
|
|
1365 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
1366
|
|
|
1367 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1368 return 0;
|
|
|
1369 }
|
|
|
1370
|
|
|
1371
|
|
|
1372 TEST_IMPL(spawn_no_path) {
|
|
|
1373 char* env[1];
|
|
|
1374 WCHAR* old_path = NULL;
|
|
|
1375 DWORD old_path_len;
|
|
|
1376
|
|
|
1377 if ((old_path_len = GetEnvironmentVariableW(L"PATH", NULL, 0)) > 0) {
|
|
|
1378 old_path = malloc(old_path_len * sizeof(WCHAR));
|
|
|
1379 GetEnvironmentVariableW(L"PATH", old_path, old_path_len);
|
|
|
1380 SetEnvironmentVariableW(L"PATH", NULL);
|
|
|
1381 }
|
|
|
1382
|
|
|
1383 init_process_options("spawn_helper1", exit_cb);
|
|
|
1384 options.env = env;
|
|
|
1385 env[0] = NULL;
|
|
|
1386
|
|
|
1387 ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options));
|
|
|
1388 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
1389
|
|
|
1390 ASSERT_EQ(1, exit_cb_called);
|
|
|
1391 ASSERT_EQ(1, close_cb_called);
|
|
|
1392
|
|
|
1393 SetEnvironmentVariableW(L"PATH", old_path);
|
|
|
1394
|
|
|
1395 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1396 return 0;
|
|
|
1397 }
|
|
|
1398
|
|
|
1399
|
|
|
1400 TEST_IMPL(spawn_no_ext) {
|
|
|
1401 char new_exepath[1024];
|
|
|
1402
|
|
|
1403 init_process_options("spawn_helper1", exit_cb);
|
|
|
1404 options.flags |= UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME;
|
|
|
1405 snprintf(new_exepath, sizeof(new_exepath), "%.*s_no_ext",
|
|
|
1406 (int) (exepath_size - sizeof(".exe") + 1),
|
|
|
1407 exepath);
|
|
|
1408 options.file = options.args[0] = new_exepath;
|
|
|
1409
|
|
|
1410 ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options));
|
|
|
1411 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
1412
|
|
|
1413 ASSERT_EQ(1, exit_cb_called);
|
|
|
1414 ASSERT_EQ(1, close_cb_called);
|
|
|
1415
|
|
|
1416 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1417 return 0;
|
|
|
1418 }
|
|
|
1419
|
|
|
1420
|
|
|
1421 TEST_IMPL(spawn_path_no_ext) {
|
|
|
1422 int r;
|
|
|
1423 int len;
|
|
|
1424 int file_len;
|
|
|
1425 char file[64];
|
|
|
1426 char path[1024];
|
|
|
1427 char* env[2];
|
|
|
1428
|
|
|
1429 /* Set up the process, but make sure that the file to run is relative and
|
|
|
1430 * requires a lookup into PATH. */
|
|
|
1431 init_process_options("spawn_helper1", exit_cb);
|
|
|
1432 options.flags |= UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME;
|
|
|
1433
|
|
|
1434 /* Set up the PATH env variable */
|
|
|
1435 for (len = strlen(exepath), file_len = 0;
|
|
|
1436 exepath[len - 1] != '/' && exepath[len - 1] != '\\';
|
|
|
1437 len--, file_len++);
|
|
|
1438 snprintf(file, sizeof(file), "%.*s_no_ext",
|
|
|
1439 (int) (file_len - sizeof(".exe") + 1),
|
|
|
1440 exepath + len);
|
|
|
1441 exepath[len] = 0;
|
|
|
1442 snprintf(path, sizeof(path), "PATH=%s", exepath);
|
|
|
1443
|
|
|
1444 env[0] = path;
|
|
|
1445 env[1] = NULL;
|
|
|
1446
|
|
|
1447 options.file = options.args[0] = file;
|
|
|
1448 options.env = env;
|
|
|
1449
|
|
|
1450 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
1451 ASSERT(r == UV_ENOENT || r == UV_EACCES);
|
|
|
1452 ASSERT_OK(uv_is_active((uv_handle_t*) &process));
|
|
|
1453 uv_close((uv_handle_t*) &process, NULL);
|
|
|
1454 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
1455
|
|
|
1456 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1457 return 0;
|
|
|
1458 }
|
|
|
1459 #endif
|
|
|
1460
|
|
|
1461 #ifndef _WIN32
|
|
|
1462 TEST_IMPL(spawn_setuid_setgid) {
|
|
|
1463 int r;
|
|
|
1464 struct passwd* pw;
|
|
|
1465 char uidstr[10];
|
|
|
1466 char gidstr[10];
|
|
|
1467
|
|
|
1468 /* if not root, then this will fail. */
|
|
|
1469 uv_uid_t uid = getuid();
|
|
|
1470 if (uid != 0) {
|
|
|
1471 RETURN_SKIP("It should be run as root user");
|
|
|
1472 }
|
|
|
1473
|
|
|
1474 init_process_options("spawn_helper_setuid_setgid", exit_cb);
|
|
|
1475
|
|
|
1476 /* become the "nobody" user. */
|
|
|
1477 pw = getpwnam("nobody");
|
|
|
1478 ASSERT_NOT_NULL(pw);
|
|
|
1479 options.uid = pw->pw_uid;
|
|
|
1480 options.gid = pw->pw_gid;
|
|
|
1481 snprintf(uidstr, sizeof(uidstr), "%d", pw->pw_uid);
|
|
|
1482 snprintf(gidstr, sizeof(gidstr), "%d", pw->pw_gid);
|
|
|
1483 options.args[2] = uidstr;
|
|
|
1484 options.args[3] = gidstr;
|
|
|
1485 options.flags = UV_PROCESS_SETUID | UV_PROCESS_SETGID;
|
|
|
1486
|
|
|
1487 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
1488 if (r == UV_EACCES)
|
|
|
1489 RETURN_SKIP("user 'nobody' cannot access the test runner");
|
|
|
1490
|
|
|
1491 ASSERT_OK(r);
|
|
|
1492
|
|
|
1493 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
1494 ASSERT_OK(r);
|
|
|
1495
|
|
|
1496 ASSERT_EQ(1, exit_cb_called);
|
|
|
1497 ASSERT_EQ(1, close_cb_called);
|
|
|
1498
|
|
|
1499 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1500 return 0;
|
|
|
1501 }
|
|
|
1502 #endif
|
|
|
1503
|
|
|
1504
|
|
|
1505 #ifndef _WIN32
|
|
|
1506 TEST_IMPL(spawn_setuid_fails) {
|
|
|
1507 int r;
|
|
|
1508
|
|
|
1509 /* if root, become nobody. */
|
|
|
1510 /* On IBMi PASE, there is no nobody user. */
|
|
|
1511 #ifndef __PASE__
|
|
|
1512 uv_uid_t uid = getuid();
|
|
|
1513 if (uid == 0) {
|
|
|
1514 struct passwd* pw;
|
|
|
1515 pw = getpwnam("nobody");
|
|
|
1516 ASSERT_NOT_NULL(pw);
|
|
|
1517 ASSERT_OK(setgid(pw->pw_gid));
|
|
|
1518 ASSERT_OK(setuid(pw->pw_uid));
|
|
|
1519 }
|
|
|
1520 #endif /* !__PASE__ */
|
|
|
1521
|
|
|
1522 init_process_options("spawn_helper1", fail_cb);
|
|
|
1523
|
|
|
1524 options.flags |= UV_PROCESS_SETUID;
|
|
|
1525 /* On IBMi PASE, there is no root user. User may grant
|
|
|
1526 * root-like privileges, including setting uid to 0.
|
|
|
1527 */
|
|
|
1528 #if defined(__PASE__)
|
|
|
1529 options.uid = -1;
|
|
|
1530 #else
|
|
|
1531 options.uid = 0;
|
|
|
1532 #endif
|
|
|
1533
|
|
|
1534 /* These flags should be ignored on Unices. */
|
|
|
1535 options.flags |= UV_PROCESS_WINDOWS_HIDE;
|
|
|
1536 options.flags |= UV_PROCESS_WINDOWS_HIDE_CONSOLE;
|
|
|
1537 options.flags |= UV_PROCESS_WINDOWS_HIDE_GUI;
|
|
|
1538 options.flags |= UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS;
|
|
|
1539
|
|
|
1540 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
1541 #if defined(__CYGWIN__)
|
|
|
1542 ASSERT_EQ(r, UV_EINVAL);
|
|
|
1543 #else
|
|
|
1544 ASSERT_EQ(r, UV_EPERM);
|
|
|
1545 #endif
|
|
|
1546
|
|
|
1547 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
1548 ASSERT_OK(r);
|
|
|
1549
|
|
|
1550 ASSERT_OK(close_cb_called);
|
|
|
1551
|
|
|
1552 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1553 return 0;
|
|
|
1554 }
|
|
|
1555
|
|
|
1556
|
|
|
1557 TEST_IMPL(spawn_setgid_fails) {
|
|
|
1558 int r;
|
|
|
1559
|
|
|
1560 /* if root, become nobody. */
|
|
|
1561 /* On IBMi PASE, there is no nobody user. */
|
|
|
1562 #ifndef __PASE__
|
|
|
1563 uv_uid_t uid = getuid();
|
|
|
1564 if (uid == 0) {
|
|
|
1565 struct passwd* pw;
|
|
|
1566 pw = getpwnam("nobody");
|
|
|
1567 ASSERT_NOT_NULL(pw);
|
|
|
1568 ASSERT_OK(setgid(pw->pw_gid));
|
|
|
1569 ASSERT_OK(setuid(pw->pw_uid));
|
|
|
1570 }
|
|
|
1571 #endif /* !__PASE__ */
|
|
|
1572
|
|
|
1573 init_process_options("spawn_helper1", fail_cb);
|
|
|
1574
|
|
|
1575 options.flags |= UV_PROCESS_SETGID;
|
|
|
1576 /* On IBMi PASE, there is no root user. User may grant
|
|
|
1577 * root-like privileges, including setting gid to 0.
|
|
|
1578 */
|
|
|
1579 #if defined(__MVS__) || defined(__PASE__)
|
|
|
1580 options.gid = -1;
|
|
|
1581 #else
|
|
|
1582 options.gid = 0;
|
|
|
1583 #endif
|
|
|
1584
|
|
|
1585 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
1586 #if defined(__CYGWIN__) || defined(__MVS__)
|
|
|
1587 ASSERT_EQ(r, UV_EINVAL);
|
|
|
1588 #else
|
|
|
1589 ASSERT_EQ(r, UV_EPERM);
|
|
|
1590 #endif
|
|
|
1591
|
|
|
1592 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
1593 ASSERT_OK(r);
|
|
|
1594
|
|
|
1595 ASSERT_OK(close_cb_called);
|
|
|
1596
|
|
|
1597 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1598 return 0;
|
|
|
1599 }
|
|
|
1600 #endif
|
|
|
1601
|
|
|
1602
|
|
|
1603 #ifdef _WIN32
|
|
|
1604
|
|
|
1605 static void exit_cb_unexpected(uv_process_t* process,
|
|
|
1606 int64_t exit_status,
|
|
|
1607 int term_signal) {
|
|
|
1608 ASSERT(0 && "should not have been called");
|
|
|
1609 }
|
|
|
1610
|
|
|
1611
|
|
|
1612 TEST_IMPL(spawn_setuid_fails) {
|
|
|
1613 int r;
|
|
|
1614
|
|
|
1615 init_process_options("spawn_helper1", exit_cb_unexpected);
|
|
|
1616
|
|
|
1617 options.flags |= UV_PROCESS_SETUID;
|
|
|
1618 options.uid = (uv_uid_t) -42424242;
|
|
|
1619
|
|
|
1620 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
1621 ASSERT_EQ(r, UV_ENOTSUP);
|
|
|
1622
|
|
|
1623 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
1624 ASSERT_OK(r);
|
|
|
1625
|
|
|
1626 ASSERT_OK(close_cb_called);
|
|
|
1627
|
|
|
1628 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1629 return 0;
|
|
|
1630 }
|
|
|
1631
|
|
|
1632
|
|
|
1633 TEST_IMPL(spawn_setgid_fails) {
|
|
|
1634 int r;
|
|
|
1635
|
|
|
1636 init_process_options("spawn_helper1", exit_cb_unexpected);
|
|
|
1637
|
|
|
1638 options.flags |= UV_PROCESS_SETGID;
|
|
|
1639 options.gid = (uv_gid_t) -42424242;
|
|
|
1640
|
|
|
1641 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
1642 ASSERT_EQ(r, UV_ENOTSUP);
|
|
|
1643
|
|
|
1644 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
1645 ASSERT_OK(r);
|
|
|
1646
|
|
|
1647 ASSERT_OK(close_cb_called);
|
|
|
1648
|
|
|
1649 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1650 return 0;
|
|
|
1651 }
|
|
|
1652 #endif
|
|
|
1653
|
|
|
1654
|
|
|
1655 TEST_IMPL(spawn_auto_unref) {
|
|
|
1656 init_process_options("spawn_helper1", NULL);
|
|
|
1657 ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options));
|
|
|
1658 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
1659 ASSERT_OK(uv_is_closing((uv_handle_t*) &process));
|
|
|
1660 uv_close((uv_handle_t*) &process, NULL);
|
|
|
1661 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
1662 ASSERT_EQ(1, uv_is_closing((uv_handle_t*) &process));
|
|
|
1663 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1664 return 0;
|
|
|
1665 }
|
|
|
1666
|
|
|
1667
|
|
|
1668 TEST_IMPL(spawn_fs_open) {
|
|
|
1669 int r;
|
|
|
1670 uv_os_fd_t fd;
|
|
|
1671 uv_os_fd_t dup_fd;
|
|
|
1672 uv_fs_t fs_req;
|
|
|
1673 uv_pipe_t in;
|
|
|
1674 uv_write_t write_req;
|
|
|
1675 uv_write_t write_req2;
|
|
|
1676 uv_buf_t buf;
|
|
|
1677 uv_stdio_container_t stdio[1];
|
|
|
1678 #ifdef _WIN32
|
|
|
1679 const char dev_null[] = "NUL";
|
|
|
1680 HMODULE kernelbase_module;
|
|
|
1681 sCompareObjectHandles pCompareObjectHandles; /* function introduced in Windows 10 */
|
|
|
1682 #else
|
|
|
1683 const char dev_null[] = "/dev/null";
|
|
|
1684 #endif
|
|
|
1685
|
|
|
1686 r = uv_fs_open(NULL, &fs_req, dev_null, UV_FS_O_RDWR, 0, NULL);
|
|
|
1687 ASSERT_NE(r, -1);
|
|
|
1688 fd = uv_get_osfhandle((uv_file) fs_req.result);
|
|
|
1689 uv_fs_req_cleanup(&fs_req);
|
|
|
1690
|
|
|
1691 init_process_options("spawn_helper8", exit_cb);
|
|
|
1692
|
|
|
1693 ASSERT_OK(uv_pipe_init(uv_default_loop(), &in, 0));
|
|
|
1694
|
|
|
1695 options.stdio = stdio;
|
|
|
1696 options.stdio[0].flags = UV_CREATE_PIPE | UV_READABLE_PIPE;
|
|
|
1697 options.stdio[0].data.stream = (uv_stream_t*) ∈
|
|
|
1698 options.stdio_count = 1;
|
|
|
1699
|
|
|
1700 /* make an inheritable copy */
|
|
|
1701 #ifdef _WIN32
|
|
|
1702 ASSERT_NE(0, DuplicateHandle(GetCurrentProcess(), fd, GetCurrentProcess(), &dup_fd,
|
|
|
1703 0, /* inherit */ TRUE, DUPLICATE_SAME_ACCESS));
|
|
|
1704 kernelbase_module = GetModuleHandleA("kernelbase.dll");
|
|
|
1705 pCompareObjectHandles = (sCompareObjectHandles)
|
|
|
1706 GetProcAddress(kernelbase_module, "CompareObjectHandles");
|
|
|
1707 ASSERT_NE(pCompareObjectHandles == NULL ||
|
|
|
1708 pCompareObjectHandles(fd, dup_fd),
|
|
|
1709 0);
|
|
|
1710 #else
|
|
|
1711 dup_fd = dup(fd);
|
|
|
1712 #endif
|
|
|
1713
|
|
|
1714 ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options));
|
|
|
1715
|
|
|
1716 buf = uv_buf_init((char*) &fd, sizeof(fd));
|
|
|
1717 ASSERT_OK(uv_write(&write_req,
|
|
|
1718 (uv_stream_t*) &in,
|
|
|
1719 &buf,
|
|
|
1720 1,
|
|
|
1721 write_null_cb));
|
|
|
1722
|
|
|
1723 buf = uv_buf_init((char*) &dup_fd, sizeof(fd));
|
|
|
1724 ASSERT_OK(uv_write(&write_req2, (uv_stream_t*) &in, &buf, 1, write_cb));
|
|
|
1725
|
|
|
1726 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
1727 ASSERT_OK(uv_fs_close(NULL, &fs_req, r, NULL));
|
|
|
1728
|
|
|
1729 ASSERT_EQ(1, exit_cb_called);
|
|
|
1730 ASSERT_EQ(2, close_cb_called); /* One for `in`, one for process */
|
|
|
1731
|
|
|
1732 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1733 return 0;
|
|
|
1734 }
|
|
|
1735
|
|
|
1736
|
|
|
1737 TEST_IMPL(closed_fd_events) {
|
|
|
1738 uv_stdio_container_t stdio[3];
|
|
|
1739 uv_pipe_t pipe_handle;
|
|
|
1740 uv_fs_t req;
|
|
|
1741 uv_buf_t bufs[1];
|
|
|
1742 uv_file fd[2];
|
|
|
1743 bufs[0] = uv_buf_init("", 1);
|
|
|
1744
|
|
|
1745 /* create a pipe and share it with a child process */
|
|
|
1746 ASSERT_OK(uv_pipe(fd, 0, 0));
|
|
|
1747 ASSERT_GT(fd[0], 2);
|
|
|
1748 ASSERT_GT(fd[1], 2);
|
|
|
1749
|
|
|
1750 /* spawn_helper4 blocks indefinitely. */
|
|
|
1751 init_process_options("spawn_helper4", exit_cb);
|
|
|
1752 options.stdio_count = 3;
|
|
|
1753 options.stdio = stdio;
|
|
|
1754 options.stdio[0].flags = UV_INHERIT_FD;
|
|
|
1755 options.stdio[0].data.fd = fd[0];
|
|
|
1756 options.stdio[1].flags = UV_IGNORE;
|
|
|
1757 options.stdio[2].flags = UV_IGNORE;
|
|
|
1758
|
|
|
1759 ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options));
|
|
|
1760 uv_unref((uv_handle_t*) &process);
|
|
|
1761
|
|
|
1762 /* read from the pipe with uv */
|
|
|
1763 ASSERT_OK(uv_pipe_init(uv_default_loop(), &pipe_handle, 0));
|
|
|
1764 ASSERT_OK(uv_pipe_open(&pipe_handle, fd[0]));
|
|
|
1765 /* uv_pipe_open() takes ownership of the file descriptor. */
|
|
|
1766 fd[0] = -1;
|
|
|
1767
|
|
|
1768 ASSERT_OK(uv_read_start((uv_stream_t*) &pipe_handle,
|
|
|
1769 on_alloc,
|
|
|
1770 on_read_once));
|
|
|
1771
|
|
|
1772 ASSERT_EQ(1, uv_fs_write(NULL, &req, fd[1], bufs, 1, -1, NULL));
|
|
|
1773 ASSERT_EQ(1, req.result);
|
|
|
1774 uv_fs_req_cleanup(&req);
|
|
|
1775
|
|
|
1776 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE));
|
|
|
1777
|
|
|
1778 /* should have received just one byte */
|
|
|
1779 ASSERT_EQ(1, output_used);
|
|
|
1780
|
|
|
1781 /* close the pipe and see if we still get events */
|
|
|
1782 uv_close((uv_handle_t*) &pipe_handle, close_cb);
|
|
|
1783
|
|
|
1784 ASSERT_EQ(1, uv_fs_write(NULL, &req, fd[1], bufs, 1, -1, NULL));
|
|
|
1785 ASSERT_EQ(1, req.result);
|
|
|
1786 uv_fs_req_cleanup(&req);
|
|
|
1787
|
|
|
1788 ASSERT_OK(uv_timer_init(uv_default_loop(), &timer));
|
|
|
1789 ASSERT_OK(uv_timer_start(&timer, timer_counter_cb, 10, 0));
|
|
|
1790
|
|
|
1791 /* see if any spurious events interrupt the timer */
|
|
|
1792 if (1 == uv_run(uv_default_loop(), UV_RUN_ONCE))
|
|
|
1793 /* have to run again to really trigger the timer */
|
|
|
1794 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE));
|
|
|
1795
|
|
|
1796 ASSERT_EQ(1, timer_counter);
|
|
|
1797
|
|
|
1798 /* cleanup */
|
|
|
1799 ASSERT_OK(uv_process_kill(&process, SIGTERM));
|
|
|
1800 #ifdef _WIN32
|
|
|
1801 ASSERT_OK(_close(fd[1]));
|
|
|
1802 #else
|
|
|
1803 ASSERT_OK(close(fd[1]));
|
|
|
1804 #endif
|
|
|
1805
|
|
|
1806 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1807 return 0;
|
|
|
1808 }
|
|
|
1809
|
|
|
1810
|
|
|
1811 TEST_IMPL(spawn_reads_child_path) {
|
|
|
1812 int r;
|
|
|
1813 int len;
|
|
|
1814 char file[64];
|
|
|
1815 char path[1024];
|
|
|
1816 char* env[3];
|
|
|
1817
|
|
|
1818 /* Need to carry over the dynamic linker path when the test runner is
|
|
|
1819 * linked against libuv.so, see https://github.com/libuv/libuv/issues/85.
|
|
|
1820 */
|
|
|
1821 #if defined(__APPLE__)
|
|
|
1822 static const char dyld_path_var[] = "DYLD_LIBRARY_PATH";
|
|
|
1823 #elif defined(__MVS__) || defined(__PASE__)
|
|
|
1824 static const char dyld_path_var[] = "LIBPATH";
|
|
|
1825 #else
|
|
|
1826 static const char dyld_path_var[] = "LD_LIBRARY_PATH";
|
|
|
1827 #endif
|
|
|
1828
|
|
|
1829 /* Set up the process, but make sure that the file to run is relative and
|
|
|
1830 * requires a lookup into PATH. */
|
|
|
1831 init_process_options("spawn_helper1", exit_cb);
|
|
|
1832
|
|
|
1833 /* Set up the PATH env variable */
|
|
|
1834 for (len = strlen(exepath);
|
|
|
1835 exepath[len - 1] != '/' && exepath[len - 1] != '\\';
|
|
|
1836 len--);
|
|
|
1837 strcpy(file, exepath + len);
|
|
|
1838 exepath[len] = 0;
|
|
|
1839 strcpy(path, "PATH=");
|
|
|
1840 strcpy(path + 5, exepath);
|
|
|
1841 #if defined(__CYGWIN__) || defined(__MSYS__)
|
|
|
1842 /* Carry over the dynamic linker path in case the test runner
|
|
|
1843 is linked against cyguv-1.dll or msys-uv-1.dll, see above. */
|
|
|
1844 {
|
|
|
1845 char* syspath = getenv("PATH");
|
|
|
1846 if (syspath != NULL) {
|
|
|
1847 strcat(path, ":");
|
|
|
1848 strcat(path, syspath);
|
|
|
1849 }
|
|
|
1850 }
|
|
|
1851 #endif
|
|
|
1852
|
|
|
1853 env[0] = path;
|
|
|
1854 env[1] = getenv(dyld_path_var);
|
|
|
1855 env[2] = NULL;
|
|
|
1856
|
|
|
1857 if (env[1] != NULL) {
|
|
|
1858 static char buf[1024 + sizeof(dyld_path_var)];
|
|
|
1859 snprintf(buf, sizeof(buf), "%s=%s", dyld_path_var, env[1]);
|
|
|
1860 env[1] = buf;
|
|
|
1861 }
|
|
|
1862
|
|
|
1863 options.file = file;
|
|
|
1864 options.args[0] = file;
|
|
|
1865 options.env = env;
|
|
|
1866
|
|
|
1867 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
1868 ASSERT_OK(r);
|
|
|
1869
|
|
|
1870 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
1871 ASSERT_OK(r);
|
|
|
1872
|
|
|
1873 ASSERT_EQ(1, exit_cb_called);
|
|
|
1874 ASSERT_EQ(1, close_cb_called);
|
|
|
1875
|
|
|
1876 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1877 return 0;
|
|
|
1878 }
|
|
|
1879
|
|
|
1880 TEST_IMPL(spawn_inherit_streams) {
|
|
|
1881 uv_process_t child_req;
|
|
|
1882 uv_stdio_container_t child_stdio[2];
|
|
|
1883 int fds_stdin[2];
|
|
|
1884 int fds_stdout[2];
|
|
|
1885 uv_pipe_t pipe_stdin_child;
|
|
|
1886 uv_pipe_t pipe_stdout_child;
|
|
|
1887 uv_pipe_t pipe_stdin_parent;
|
|
|
1888 uv_pipe_t pipe_stdout_parent;
|
|
|
1889 unsigned char ubuf[OUTPUT_SIZE - 1];
|
|
|
1890 uv_buf_t buf;
|
|
|
1891 unsigned int i;
|
|
|
1892 int r;
|
|
|
1893 int bidir;
|
|
|
1894 uv_write_t write_req;
|
|
|
1895 uv_loop_t* loop;
|
|
|
1896
|
|
|
1897 init_process_options("spawn_helper9", exit_cb);
|
|
|
1898
|
|
|
1899 loop = uv_default_loop();
|
|
|
1900 ASSERT_OK(uv_pipe_init(loop, &pipe_stdin_child, 0));
|
|
|
1901 ASSERT_OK(uv_pipe_init(loop, &pipe_stdout_child, 0));
|
|
|
1902 ASSERT_OK(uv_pipe_init(loop, &pipe_stdin_parent, 0));
|
|
|
1903 ASSERT_OK(uv_pipe_init(loop, &pipe_stdout_parent, 0));
|
|
|
1904
|
|
|
1905 ASSERT_OK(uv_pipe(fds_stdin, 0, 0));
|
|
|
1906 ASSERT_OK(uv_pipe(fds_stdout, 0, 0));
|
|
|
1907
|
|
|
1908 ASSERT_OK(uv_pipe_open(&pipe_stdin_child, fds_stdin[0]));
|
|
|
1909 ASSERT_OK(uv_pipe_open(&pipe_stdout_child, fds_stdout[1]));
|
|
|
1910 ASSERT_OK(uv_pipe_open(&pipe_stdin_parent, fds_stdin[1]));
|
|
|
1911 ASSERT_OK(uv_pipe_open(&pipe_stdout_parent, fds_stdout[0]));
|
|
|
1912 ASSERT(uv_is_readable((uv_stream_t*) &pipe_stdin_child));
|
|
|
1913 ASSERT(uv_is_writable((uv_stream_t*) &pipe_stdout_child));
|
|
|
1914 ASSERT(uv_is_writable((uv_stream_t*) &pipe_stdin_parent));
|
|
|
1915 ASSERT(uv_is_readable((uv_stream_t*) &pipe_stdout_parent));
|
|
|
1916 /* Some systems (SVR4) open a bidirectional pipe, most don't. */
|
|
|
1917 bidir = uv_is_writable((uv_stream_t*) &pipe_stdin_child);
|
|
|
1918 ASSERT_EQ(uv_is_readable((uv_stream_t*) &pipe_stdout_child), bidir);
|
|
|
1919 ASSERT_EQ(uv_is_readable((uv_stream_t*) &pipe_stdin_parent), bidir);
|
|
|
1920 ASSERT_EQ(uv_is_writable((uv_stream_t*) &pipe_stdout_parent), bidir);
|
|
|
1921
|
|
|
1922 child_stdio[0].flags = UV_INHERIT_STREAM;
|
|
|
1923 child_stdio[0].data.stream = (uv_stream_t *) &pipe_stdin_child;
|
|
|
1924
|
|
|
1925 child_stdio[1].flags = UV_INHERIT_STREAM;
|
|
|
1926 child_stdio[1].data.stream = (uv_stream_t *) &pipe_stdout_child;
|
|
|
1927
|
|
|
1928 options.stdio = child_stdio;
|
|
|
1929 options.stdio_count = 2;
|
|
|
1930
|
|
|
1931 ASSERT_OK(uv_spawn(loop, &child_req, &options));
|
|
|
1932
|
|
|
1933 uv_close((uv_handle_t*) &pipe_stdin_child, NULL);
|
|
|
1934 uv_close((uv_handle_t*) &pipe_stdout_child, NULL);
|
|
|
1935
|
|
|
1936 buf = uv_buf_init((char*) ubuf, sizeof ubuf);
|
|
|
1937 for (i = 0; i < sizeof ubuf; ++i)
|
|
|
1938 ubuf[i] = i & 255u;
|
|
|
1939 memset(output, 0, sizeof ubuf);
|
|
|
1940
|
|
|
1941 r = uv_write(&write_req,
|
|
|
1942 (uv_stream_t*) &pipe_stdin_parent,
|
|
|
1943 &buf,
|
|
|
1944 1,
|
|
|
1945 write_cb);
|
|
|
1946 ASSERT_OK(r);
|
|
|
1947
|
|
|
1948 r = uv_read_start((uv_stream_t*) &pipe_stdout_parent, on_alloc, on_read);
|
|
|
1949 ASSERT_OK(r);
|
|
|
1950
|
|
|
1951 r = uv_run(loop, UV_RUN_DEFAULT);
|
|
|
1952 ASSERT_OK(r);
|
|
|
1953
|
|
|
1954 ASSERT_EQ(1, exit_cb_called);
|
|
|
1955 ASSERT_EQ(3, close_cb_called);
|
|
|
1956
|
|
|
1957 r = memcmp(ubuf, output, sizeof ubuf);
|
|
|
1958 ASSERT_OK(r);
|
|
|
1959
|
|
|
1960 MAKE_VALGRIND_HAPPY(loop);
|
|
|
1961 return 0;
|
|
|
1962 }
|
|
|
1963
|
|
|
1964 TEST_IMPL(spawn_quoted_path) {
|
|
|
1965 #ifndef _WIN32
|
|
|
1966 RETURN_SKIP("Test for Windows");
|
|
|
1967 #else
|
|
|
1968 char* quoted_path_env[2];
|
|
|
1969 args[0] = "not_existing";
|
|
|
1970 args[1] = NULL;
|
|
|
1971 options.file = args[0];
|
|
|
1972 options.args = args;
|
|
|
1973 options.exit_cb = exit_cb;
|
|
|
1974 options.flags = 0;
|
|
|
1975 /* We test if search_path works correctly with semicolons in quoted path. We
|
|
|
1976 * will use an invalid drive, so we are sure no executable is spawned. */
|
|
|
1977 quoted_path_env[0] = "PATH=\"xyz:\\test;\";xyz:\\other";
|
|
|
1978 quoted_path_env[1] = NULL;
|
|
|
1979 options.env = quoted_path_env;
|
|
|
1980
|
|
|
1981 /* We test if libuv will not segfault. */
|
|
|
1982 uv_spawn(uv_default_loop(), &process, &options);
|
|
|
1983
|
|
|
1984 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
1985 return 0;
|
|
|
1986 #endif
|
|
|
1987 }
|
|
|
1988
|
|
|
1989 TEST_IMPL(spawn_exercise_sigchld_issue) {
|
|
|
1990 int r;
|
|
|
1991 int i;
|
|
|
1992 uv_process_options_t dummy_options = {0};
|
|
|
1993 uv_process_t dummy_processes[100];
|
|
|
1994 char* args[2];
|
|
|
1995
|
|
|
1996 init_process_options("spawn_helper1", exit_cb);
|
|
|
1997
|
|
|
1998 r = uv_spawn(uv_default_loop(), &process, &options);
|
|
|
1999 ASSERT_OK(r);
|
|
|
2000
|
|
|
2001 // This test exercises a bug in the darwin kernel that causes SIGCHLD not to
|
|
|
2002 // be delivered sometimes. Calling posix_spawn many times increases the
|
|
|
2003 // likelihood of encountering this issue, so spin a few times to make this
|
|
|
2004 // test more reliable.
|
|
|
2005 dummy_options.file = args[0] = "program-that-had-better-not-exist";
|
|
|
2006 args[1] = NULL;
|
|
|
2007 dummy_options.args = args;
|
|
|
2008 dummy_options.exit_cb = fail_cb;
|
|
|
2009 dummy_options.flags = 0;
|
|
|
2010 for (i = 0; i < 100; i++) {
|
|
|
2011 r = uv_spawn(uv_default_loop(), &dummy_processes[i], &dummy_options);
|
|
|
2012 if (r != UV_ENOENT)
|
|
|
2013 ASSERT_EQ(r, UV_EACCES);
|
|
|
2014 uv_close((uv_handle_t*) &dummy_processes[i], close_cb);
|
|
|
2015 }
|
|
|
2016
|
|
|
2017 r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
|
|
|
2018 ASSERT_OK(r);
|
|
|
2019
|
|
|
2020 ASSERT_EQ(1, exit_cb_called);
|
|
|
2021 ASSERT_EQ(101, close_cb_called);
|
|
|
2022
|
|
|
2023 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
2024 return 0;
|
|
|
2025 }
|
|
|
2026
|
|
|
2027 /* Helper for child process of spawn_inherit_streams */
|
|
|
2028 #ifndef _WIN32
|
|
|
2029 void spawn_stdin_stdout(void) {
|
|
|
2030 char buf[1024];
|
|
|
2031 char* pbuf;
|
|
|
2032 for (;;) {
|
|
|
2033 ssize_t r, w, c;
|
|
|
2034 do {
|
|
|
2035 r = read(0, buf, sizeof buf);
|
|
|
2036 } while (r == -1 && errno == EINTR);
|
|
|
2037 if (r == 0) {
|
|
|
2038 return;
|
|
|
2039 }
|
|
|
2040 ASSERT_GT(r, 0);
|
|
|
2041 c = r;
|
|
|
2042 pbuf = buf;
|
|
|
2043 while (c) {
|
|
|
2044 do {
|
|
|
2045 w = write(1, pbuf, (size_t)c);
|
|
|
2046 } while (w == -1 && errno == EINTR);
|
|
|
2047 ASSERT_GE(w, 0);
|
|
|
2048 pbuf = pbuf + w;
|
|
|
2049 c = c - w;
|
|
|
2050 }
|
|
|
2051 }
|
|
|
2052 }
|
|
|
2053 #else
|
|
|
2054 void spawn_stdin_stdout(void) {
|
|
|
2055 char buf[1024];
|
|
|
2056 char* pbuf;
|
|
|
2057 HANDLE h_stdin = GetStdHandle(STD_INPUT_HANDLE);
|
|
|
2058 HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
|
2059 ASSERT_PTR_NE(h_stdin, INVALID_HANDLE_VALUE);
|
|
|
2060 ASSERT_PTR_NE(h_stdout, INVALID_HANDLE_VALUE);
|
|
|
2061 for (;;) {
|
|
|
2062 DWORD n_read;
|
|
|
2063 DWORD n_written;
|
|
|
2064 DWORD to_write;
|
|
|
2065 if (!ReadFile(h_stdin, buf, sizeof buf, &n_read, NULL)) {
|
|
|
2066 ASSERT_EQ(GetLastError(), ERROR_BROKEN_PIPE);
|
|
|
2067 return;
|
|
|
2068 }
|
|
|
2069 to_write = n_read;
|
|
|
2070 pbuf = buf;
|
|
|
2071 while (to_write) {
|
|
|
2072 ASSERT(WriteFile(h_stdout, pbuf, to_write, &n_written, NULL));
|
|
|
2073 to_write -= n_written;
|
|
|
2074 pbuf += n_written;
|
|
|
2075 }
|
|
|
2076 }
|
|
|
2077 }
|
|
|
2078 #endif /* !_WIN32 */
|
|
|
2079
|
|
|
2080 TEST_IMPL(spawn_relative_path) {
|
|
|
2081 char* sep;
|
|
|
2082
|
|
|
2083 init_process_options("spawn_helper1", exit_cb);
|
|
|
2084
|
|
|
2085 exepath_size = sizeof(exepath) - 2;
|
|
|
2086 ASSERT_OK(uv_exepath(exepath, &exepath_size));
|
|
|
2087 exepath[exepath_size] = '\0';
|
|
|
2088
|
|
|
2089 /* Poor man's basename(3). */
|
|
|
2090 sep = strrchr(exepath, '/');
|
|
|
2091 if (sep == NULL)
|
|
|
2092 sep = strrchr(exepath, '\\');
|
|
|
2093 ASSERT_NOT_NULL(sep);
|
|
|
2094
|
|
|
2095 /* Split into dirname and basename and make basename relative. */
|
|
|
2096 memmove(sep + 2, sep, 1 + strlen(sep));
|
|
|
2097 sep[0] = '\0';
|
|
|
2098 sep[1] = '.';
|
|
|
2099 sep[2] = '/';
|
|
|
2100
|
|
|
2101 options.cwd = exepath;
|
|
|
2102 options.file = options.args[0] = sep + 1;
|
|
|
2103
|
|
|
2104 ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options));
|
|
|
2105 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
2106
|
|
|
2107 ASSERT_EQ(1, exit_cb_called);
|
|
|
2108 ASSERT_EQ(1, close_cb_called);
|
|
|
2109
|
|
|
2110 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
2111 return 0;
|
|
|
2112 }
|
