1 #include <config.h>
2
3 //#define SPAWN_DEBUG
4
5 #if !defined(SPAWN_DEBUG) || defined(_MSC_VER)
6 #define PING()
7 #else
8 #define PING() fprintf (stderr, "%s:%s:%d\n", __FILE__, __FUNCTION__, __LINE__); fflush (stderr)
9 #endif
10
11 #include <stdio.h>
12
13 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
14 /* dbus-spawn-win32.c Wrapper around g_spawn
15 *
16 * Copyright (C) 2002, 2003, 2004 Red Hat, Inc.
17 * Copyright (C) 2003 CodeFactory AB
18 * Copyright (C) 2005 Novell, Inc.
19 *
20 * Licensed under the Academic Free License version 2.1
21 *
22 * This program is free software; you can redistribute it and/or modify
23 * it under the terms of the GNU General Public License as published by
24 * the Free Software Foundation; either version 2 of the License, or
25 * (at your option) any later version.
26 *
27 * This program is distributed in the hope that it will be useful,
28 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 * GNU General Public License for more details.
31 *
32 * You should have received a copy of the GNU General Public License
33 * along with this program; if not, write to the Free Software
34 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
35 *
36 */
37 #include "dbus-spawn.h"
38 #include "dbus-sysdeps.h"
39 #include "dbus-sysdeps-win.h"
40 #include "dbus-internals.h"
41 #include "dbus-test.h"
42 #include "dbus-protocol.h"
43
44 #define WIN32_LEAN_AND_MEAN
45 #include <windows.h>
46 //#define STRICT
47 //#include <windows.h>
48 //#undef STRICT
49 #include <winsock2.h>
50 #undef interface
51
52 #include <stdlib.h>
53
54 #ifndef DBUS_WINCE
55 #include <process.h>
56 #endif
57
58 /**
59 * Babysitter implementation details
60 */
61 struct DBusBabysitter
62 {
63 int refcount;
64
65 HANDLE start_sync_event;
66 #ifdef DBUS_BUILD_TESTS
67
68 HANDLE end_sync_event;
69 #endif
70
71 char *executable;
72 DBusSpawnChildSetupFunc child_setup;
73 void *user_data;
74
75 int argc;
76 char **argv;
77 char **envp;
78
79 HANDLE child_handle;
80 int socket_to_babysitter; /* Connection to the babysitter thread */
81 int socket_to_main;
82
83 DBusWatchList *watches;
84 DBusWatch *sitter_watch;
85 DBusBabysitterFinishedFunc finished_cb;
86 void *finished_data;
87
88 dbus_bool_t have_spawn_errno;
89 int spawn_errno;
90 dbus_bool_t have_child_status;
91 int child_status;
92 };
93
94 static DBusBabysitter*
_dbus_babysitter_new(void)95 _dbus_babysitter_new (void)
96 {
97 DBusBabysitter *sitter;
98
99 sitter = dbus_new0 (DBusBabysitter, 1);
100 if (sitter == NULL)
101 return NULL;
102
103 sitter->refcount = 1;
104
105 sitter->start_sync_event = CreateEvent (NULL, FALSE, FALSE, NULL);
106 if (sitter->start_sync_event == NULL)
107 {
108 _dbus_babysitter_unref (sitter);
109 return NULL;
110 }
111
112 #ifdef DBUS_BUILD_TESTS
113 sitter->end_sync_event = CreateEvent (NULL, FALSE, FALSE, NULL);
114 if (sitter->end_sync_event == NULL)
115 {
116 _dbus_babysitter_unref (sitter);
117 return NULL;
118 }
119 #endif
120
121 sitter->child_handle = NULL;
122
123 sitter->socket_to_babysitter = sitter->socket_to_main = -1;
124
125 sitter->argc = 0;
126 sitter->argv = NULL;
127 sitter->envp = NULL;
128
129 sitter->watches = _dbus_watch_list_new ();
130 if (sitter->watches == NULL)
131 {
132 _dbus_babysitter_unref (sitter);
133 return NULL;
134 }
135
136 sitter->have_spawn_errno = FALSE;
137 sitter->have_child_status = FALSE;
138
139 return sitter;
140 }
141
142 /**
143 * Increment the reference count on the babysitter object.
144 *
145 * @param sitter the babysitter
146 * @returns the babysitter
147 */
148 DBusBabysitter *
_dbus_babysitter_ref(DBusBabysitter * sitter)149 _dbus_babysitter_ref (DBusBabysitter *sitter)
150 {
151 PING();
152 _dbus_assert (sitter != NULL);
153 _dbus_assert (sitter->refcount > 0);
154
155 sitter->refcount += 1;
156
157 return sitter;
158 }
159
160 static void
close_socket_to_babysitter(DBusBabysitter * sitter)161 close_socket_to_babysitter (DBusBabysitter *sitter)
162 {
163 _dbus_verbose ("Closing babysitter\n");
164
165 if (sitter->sitter_watch != NULL)
166 {
167 _dbus_assert (sitter->watches != NULL);
168 _dbus_watch_list_remove_watch (sitter->watches, sitter->sitter_watch);
169 _dbus_watch_invalidate (sitter->sitter_watch);
170 _dbus_watch_unref (sitter->sitter_watch);
171 sitter->sitter_watch = NULL;
172 }
173
174 if (sitter->socket_to_babysitter != -1)
175 {
176 _dbus_close_socket (sitter->socket_to_babysitter, NULL);
177 sitter->socket_to_babysitter = -1;
178 }
179 }
180
181 /**
182 * Decrement the reference count on the babysitter object.
183 *
184 * @param sitter the babysitter
185 */
186 void
_dbus_babysitter_unref(DBusBabysitter * sitter)187 _dbus_babysitter_unref (DBusBabysitter *sitter)
188 {
189 int i;
190
191 PING();
192 _dbus_assert (sitter != NULL);
193 _dbus_assert (sitter->refcount > 0);
194
195 sitter->refcount -= 1;
196
197 if (sitter->refcount == 0)
198 {
199 close_socket_to_babysitter (sitter);
200
201 if (sitter->socket_to_main != -1)
202 {
203 _dbus_close_socket (sitter->socket_to_main, NULL);
204 sitter->socket_to_main = -1;
205 }
206
207 PING();
208 if (sitter->argv != NULL)
209 {
210 for (i = 0; i < sitter->argc; i++)
211 if (sitter->argv[i] != NULL)
212 {
213 dbus_free (sitter->argv[i]);
214 sitter->argv[i] = NULL;
215 }
216 dbus_free (sitter->argv);
217 sitter->argv = NULL;
218 }
219
220 if (sitter->envp != NULL)
221 {
222 char **e = sitter->envp;
223
224 while (*e)
225 dbus_free (*e++);
226 dbus_free (sitter->envp);
227 sitter->envp = NULL;
228 }
229
230 if (sitter->child_handle != NULL)
231 {
232 CloseHandle (sitter->child_handle);
233 sitter->child_handle = NULL;
234 }
235
236 if (sitter->sitter_watch)
237 {
238 _dbus_watch_invalidate (sitter->sitter_watch);
239 _dbus_watch_unref (sitter->sitter_watch);
240 sitter->sitter_watch = NULL;
241 }
242
243 if (sitter->watches)
244 _dbus_watch_list_free (sitter->watches);
245
246 if (sitter->start_sync_event != NULL)
247 {
248 PING();
249 CloseHandle (sitter->start_sync_event);
250 sitter->start_sync_event = NULL;
251 }
252
253 #ifdef DBUS_BUILD_TESTS
254 if (sitter->end_sync_event != NULL)
255 {
256 CloseHandle (sitter->end_sync_event);
257 sitter->end_sync_event = NULL;
258 }
259 #endif
260
261 dbus_free (sitter->executable);
262
263 dbus_free (sitter);
264 }
265 }
266
267 void
_dbus_babysitter_kill_child(DBusBabysitter * sitter)268 _dbus_babysitter_kill_child (DBusBabysitter *sitter)
269 {
270 PING();
271 if (sitter->child_handle == NULL)
272 return; /* child is already dead, or we're so hosed we'll never recover */
273
274 PING();
275 TerminateProcess (sitter->child_handle, 12345);
276 }
277
278 /**
279 * Checks whether the child has exited, without blocking.
280 *
281 * @param sitter the babysitter
282 */
283 dbus_bool_t
_dbus_babysitter_get_child_exited(DBusBabysitter * sitter)284 _dbus_babysitter_get_child_exited (DBusBabysitter *sitter)
285 {
286 PING();
287 return (sitter->child_handle == NULL);
288 }
289
290 /**
291 * Gets the exit status of the child. We do this so implementation specific
292 * detail is not cluttering up dbus, for example the system launcher code.
293 * This can only be called if the child has exited, i.e. call
294 * _dbus_babysitter_get_child_exited(). It returns FALSE if the child
295 * did not return a status code, e.g. because the child was signaled
296 * or we failed to ever launch the child in the first place.
297 *
298 * @param sitter the babysitter
299 * @param status the returned status code
300 * @returns #FALSE on failure
301 */
302 dbus_bool_t
_dbus_babysitter_get_child_exit_status(DBusBabysitter * sitter,int * status)303 _dbus_babysitter_get_child_exit_status (DBusBabysitter *sitter,
304 int *status)
305 {
306 if (!_dbus_babysitter_get_child_exited (sitter))
307 _dbus_assert_not_reached ("Child has not exited");
308
309 if (!sitter->have_child_status ||
310 sitter->child_status == STILL_ACTIVE)
311 return FALSE;
312
313 *status = sitter->child_status;
314 return TRUE;
315 }
316
317 /**
318 * Sets the #DBusError with an explanation of why the spawned
319 * child process exited (on a signal, or whatever). If
320 * the child process has not exited, does nothing (error
321 * will remain unset).
322 *
323 * @param sitter the babysitter
324 * @param error an error to fill in
325 */
326 void
_dbus_babysitter_set_child_exit_error(DBusBabysitter * sitter,DBusError * error)327 _dbus_babysitter_set_child_exit_error (DBusBabysitter *sitter,
328 DBusError *error)
329 {
330 PING();
331 if (!_dbus_babysitter_get_child_exited (sitter))
332 return;
333
334 PING();
335 if (sitter->have_spawn_errno)
336 {
337 char *emsg = _dbus_win_error_string (sitter->spawn_errno);
338 dbus_set_error (error, DBUS_ERROR_SPAWN_EXEC_FAILED,
339 "Failed to execute program %s: %s",
340 sitter->executable, emsg);
341 _dbus_win_free_error_string (emsg);
342 }
343 else if (sitter->have_child_status)
344 {
345 PING();
346 dbus_set_error (error, DBUS_ERROR_SPAWN_CHILD_EXITED,
347 "Process %s exited with status %d",
348 sitter->executable, sitter->child_status);
349 }
350 else
351 {
352 PING();
353 dbus_set_error (error, DBUS_ERROR_FAILED,
354 "Process %s exited, status unknown",
355 sitter->executable);
356 }
357 PING();
358 }
359
360 dbus_bool_t
_dbus_babysitter_set_watch_functions(DBusBabysitter * sitter,DBusAddWatchFunction add_function,DBusRemoveWatchFunction remove_function,DBusWatchToggledFunction toggled_function,void * data,DBusFreeFunction free_data_function)361 _dbus_babysitter_set_watch_functions (DBusBabysitter *sitter,
362 DBusAddWatchFunction add_function,
363 DBusRemoveWatchFunction remove_function,
364 DBusWatchToggledFunction toggled_function,
365 void *data,
366 DBusFreeFunction free_data_function)
367 {
368 PING();
369 return _dbus_watch_list_set_functions (sitter->watches,
370 add_function,
371 remove_function,
372 toggled_function,
373 data,
374 free_data_function);
375 }
376
377 static dbus_bool_t
handle_watch(DBusWatch * watch,unsigned int condition,void * data)378 handle_watch (DBusWatch *watch,
379 unsigned int condition,
380 void *data)
381 {
382 DBusBabysitter *sitter = data;
383
384 /* On Unix dbus-spawn uses a babysitter *process*, thus it has to
385 * actually send the exit statuses, error codes and whatnot through
386 * sockets and/or pipes. On Win32, the babysitter is jus a thread,
387 * so it can set the status fields directly in the babysitter struct
388 * just fine. The socket pipe is used just so we can watch it with
389 * select(), as soon as anything is written to it we know that the
390 * babysitter thread has recorded the status in the babysitter
391 * struct.
392 */
393
394 PING();
395 close_socket_to_babysitter (sitter);
396 PING();
397
398 if (_dbus_babysitter_get_child_exited (sitter) &&
399 sitter->finished_cb != NULL)
400 {
401 sitter->finished_cb (sitter, sitter->finished_data);
402 sitter->finished_cb = NULL;
403 }
404
405 return TRUE;
406 }
407
408 /* protect_argv lifted from GLib, relicensed by author, Tor Lillqvist */
409 static int
protect_argv(char ** argv,char *** new_argv)410 protect_argv (char **argv,
411 char ***new_argv)
412 {
413 int i;
414 int argc = 0;
415
416 while (argv[argc])
417 ++argc;
418 *new_argv = dbus_malloc ((argc + 1) * sizeof (char *));
419 if (*new_argv == NULL)
420 return -1;
421
422 for (i = 0; i < argc; i++)
423 (*new_argv)[i] = NULL;
424
425 /* Quote each argv element if necessary, so that it will get
426 * reconstructed correctly in the C runtime startup code. Note that
427 * the unquoting algorithm in the C runtime is really weird, and
428 * rather different than what Unix shells do. See stdargv.c in the C
429 * runtime sources (in the Platform SDK, in src/crt).
430 *
431 * Note that an new_argv[0] constructed by this function should
432 * *not* be passed as the filename argument to a spawn* or exec*
433 * family function. That argument should be the real file name
434 * without any quoting.
435 */
436 for (i = 0; i < argc; i++)
437 {
438 char *p = argv[i];
439 char *q;
440 int len = 0;
441 int need_dblquotes = FALSE;
442 while (*p)
443 {
444 if (*p == ' ' || *p == '\t')
445 need_dblquotes = TRUE;
446 else if (*p == '"')
447 len++;
448 else if (*p == '\\')
449 {
450 char *pp = p;
451 while (*pp && *pp == '\\')
452 pp++;
453 if (*pp == '"')
454 len++;
455 }
456 len++;
457 p++;
458 }
459
460 q = (*new_argv)[i] = dbus_malloc (len + need_dblquotes*2 + 1);
461
462 if (q == NULL)
463 return -1;
464
465
466 p = argv[i];
467
468 if (need_dblquotes)
469 *q++ = '"';
470
471 while (*p)
472 {
473 if (*p == '"')
474 *q++ = '\\';
475 else if (*p == '\\')
476 {
477 char *pp = p;
478 while (*pp && *pp == '\\')
479 pp++;
480 if (*pp == '"')
481 *q++ = '\\';
482 }
483 *q++ = *p;
484 p++;
485 }
486
487 if (need_dblquotes)
488 *q++ = '"';
489 *q++ = '\0';
490 /* printf ("argv[%d]:%s, need_dblquotes:%s len:%d => %s\n", i, argv[i], need_dblquotes?"TRUE":"FALSE", len, (*new_argv)[i]); */
491 }
492 (*new_argv)[argc] = NULL;
493
494 return argc;
495 }
496
497
498 /* From GPGME, relicensed by g10 Code GmbH. */
499 static char *
compose_string(char ** strings,char separator)500 compose_string (char **strings, char separator)
501 {
502 int i;
503 int n = 0;
504 char *buf;
505 char *p;
506
507 if (!strings || !strings[0])
508 return 0;
509 for (i = 0; strings[i]; i++)
510 n += strlen (strings[i]) + 1;
511 n++;
512
513 buf = p = malloc (n);
514 if (!buf)
515 return NULL;
516 for (i = 0; strings[i]; i++)
517 {
518 strcpy (p, strings[i]);
519 p += strlen (strings[i]);
520 *(p++) = separator;
521 }
522 p--;
523 *(p++) = '\0';
524 *p = '\0';
525
526 return buf;
527 }
528
529 static char *
build_commandline(char ** argv)530 build_commandline (char **argv)
531 {
532 return compose_string (argv, ' ');
533 }
534
535 static char *
build_env_string(char ** envp)536 build_env_string (char** envp)
537 {
538 return compose_string (envp, '\0');
539 }
540
541 static HANDLE
spawn_program(char * name,char ** argv,char ** envp)542 spawn_program (char* name, char** argv, char** envp)
543 {
544 PROCESS_INFORMATION pi = { NULL, 0, 0, 0 };
545 STARTUPINFOA si;
546 char *arg_string, *env_string;
547 BOOL result;
548
549 #ifdef DBUS_WINCE
550 if (argv && argv[0])
551 arg_string = build_commandline (argv + 1);
552 else
553 arg_string = NULL;
554 #else
555 arg_string = build_commandline (argv);
556 #endif
557 if (!arg_string)
558 return INVALID_HANDLE_VALUE;
559
560 env_string = build_env_string(envp);
561
562 memset (&si, 0, sizeof (si));
563 si.cb = sizeof (si);
564 #ifdef DBUS_WINCE
565 result = CreateProcessA (name, arg_string, NULL, NULL, FALSE, 0,
566 #else
567 result = CreateProcessA (NULL, arg_string, NULL, NULL, FALSE, 0,
568 #endif
569 (LPVOID)env_string, NULL, &si, &pi);
570 free (arg_string);
571 if (env_string)
572 free (env_string);
573
574 if (!result)
575 return INVALID_HANDLE_VALUE;
576
577 CloseHandle (pi.hThread);
578 return pi.hProcess;
579 }
580
581
582 static DWORD __stdcall
babysitter(void * parameter)583 babysitter (void *parameter)
584 {
585 DBusBabysitter *sitter = (DBusBabysitter *) parameter;
586
587 PING();
588 _dbus_babysitter_ref (sitter);
589
590 if (sitter->child_setup)
591 {
592 PING();
593 (*sitter->child_setup) (sitter->user_data);
594 }
595
596 _dbus_verbose ("babysitter: spawning %s\n", sitter->executable);
597
598 PING();
599 sitter->child_handle = spawn_program (sitter->executable,
600 sitter->argv, sitter->envp);
601
602 PING();
603 if (sitter->child_handle == (HANDLE) -1)
604 {
605 sitter->child_handle = NULL;
606 sitter->have_spawn_errno = TRUE;
607 sitter->spawn_errno = GetLastError();
608 }
609
610 PING();
611 SetEvent (sitter->start_sync_event);
612
613 if (sitter->child_handle != NULL)
614 {
615 int ret;
616 DWORD status;
617
618 PING();
619 WaitForSingleObject (sitter->child_handle, INFINITE);
620
621 PING();
622 ret = GetExitCodeProcess (sitter->child_handle, &status);
623
624 sitter->child_status = status;
625 sitter->have_child_status = TRUE;
626
627 CloseHandle (sitter->child_handle);
628 sitter->child_handle = NULL;
629 }
630
631 #ifdef DBUS_BUILD_TESTS
632 SetEvent (sitter->end_sync_event);
633 #endif
634
635 PING();
636 send (sitter->socket_to_main, " ", 1, 0);
637
638 _dbus_babysitter_unref (sitter);
639
640 return 0;
641 }
642
643 dbus_bool_t
_dbus_spawn_async_with_babysitter(DBusBabysitter ** sitter_p,char ** argv,char ** envp,DBusSpawnChildSetupFunc child_setup,void * user_data,DBusError * error)644 _dbus_spawn_async_with_babysitter (DBusBabysitter **sitter_p,
645 char **argv,
646 char **envp,
647 DBusSpawnChildSetupFunc child_setup,
648 void *user_data,
649 DBusError *error)
650 {
651 DBusBabysitter *sitter;
652 HANDLE sitter_thread;
653 DWORD sitter_thread_id;
654
655 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
656
657 *sitter_p = NULL;
658
659 PING();
660 sitter = _dbus_babysitter_new ();
661 if (sitter == NULL)
662 {
663 _DBUS_SET_OOM (error);
664 return FALSE;
665 }
666
667 sitter->child_setup = child_setup;
668 sitter->user_data = user_data;
669
670 sitter->executable = _dbus_strdup (argv[0]);
671 if (sitter->executable == NULL)
672 {
673 _DBUS_SET_OOM (error);
674 goto out0;
675 }
676
677 PING();
678 if (!_dbus_full_duplex_pipe (&sitter->socket_to_babysitter,
679 &sitter->socket_to_main,
680 FALSE, error))
681 goto out0;
682
683 sitter->sitter_watch = _dbus_watch_new (sitter->socket_to_babysitter,
684 DBUS_WATCH_READABLE,
685 TRUE, handle_watch, sitter, NULL);
686 PING();
687 if (sitter->sitter_watch == NULL)
688 {
689 _DBUS_SET_OOM (error);
690 goto out0;
691 }
692
693 PING();
694 if (!_dbus_watch_list_add_watch (sitter->watches, sitter->sitter_watch))
695 {
696 /* we need to free it early so the destructor won't try to remove it
697 * without it having been added, which DBusLoop doesn't allow */
698 _dbus_watch_invalidate (sitter->sitter_watch);
699 _dbus_watch_unref (sitter->sitter_watch);
700 sitter->sitter_watch = NULL;
701
702 _DBUS_SET_OOM (error);
703 goto out0;
704 }
705
706 sitter->argc = protect_argv (argv, &sitter->argv);
707 if (sitter->argc == -1)
708 {
709 _DBUS_SET_OOM (error);
710 goto out0;
711 }
712 sitter->envp = envp;
713
714 PING();
715 sitter_thread = (HANDLE) CreateThread (NULL, 0, babysitter,
716 sitter, 0, &sitter_thread_id);
717
718 if (sitter_thread == 0)
719 {
720 PING();
721 dbus_set_error_const (error, DBUS_ERROR_SPAWN_FORK_FAILED,
722 "Failed to create new thread");
723 goto out0;
724 }
725 CloseHandle (sitter_thread);
726
727 PING();
728 WaitForSingleObject (sitter->start_sync_event, INFINITE);
729
730 PING();
731 if (sitter_p != NULL)
732 *sitter_p = sitter;
733 else
734 _dbus_babysitter_unref (sitter);
735
736 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
737
738 PING();
739 return TRUE;
740
741 out0:
742 _dbus_babysitter_unref (sitter);
743
744 return FALSE;
745 }
746
747 void
_dbus_babysitter_set_result_function(DBusBabysitter * sitter,DBusBabysitterFinishedFunc finished,void * user_data)748 _dbus_babysitter_set_result_function (DBusBabysitter *sitter,
749 DBusBabysitterFinishedFunc finished,
750 void *user_data)
751 {
752 sitter->finished_cb = finished;
753 sitter->finished_data = user_data;
754 }
755
756 #ifdef DBUS_BUILD_TESTS
757
758 static char *
get_test_exec(const char * exe,DBusString * scratch_space)759 get_test_exec (const char *exe,
760 DBusString *scratch_space)
761 {
762 const char *dbus_test_exec;
763
764 dbus_test_exec = _dbus_getenv ("DBUS_TEST_EXEC");
765
766 if (dbus_test_exec == NULL)
767 dbus_test_exec = DBUS_TEST_EXEC;
768
769 if (!_dbus_string_init (scratch_space))
770 return NULL;
771
772 if (!_dbus_string_append_printf (scratch_space, "%s/%s%s",
773 dbus_test_exec, exe, DBUS_EXEEXT))
774 {
775 _dbus_string_free (scratch_space);
776 return NULL;
777 }
778
779 return _dbus_string_get_data (scratch_space);
780 }
781
782 #define LIVE_CHILDREN(sitter) ((sitter)->child_handle != NULL)
783
784 static void
_dbus_babysitter_block_for_child_exit(DBusBabysitter * sitter)785 _dbus_babysitter_block_for_child_exit (DBusBabysitter *sitter)
786 {
787 if (sitter->child_handle == NULL)
788 return;
789
790 WaitForSingleObject (sitter->end_sync_event, INFINITE);
791 }
792
793 static dbus_bool_t
check_spawn_nonexistent(void * data)794 check_spawn_nonexistent (void *data)
795 {
796 char *argv[4] = { NULL, NULL, NULL, NULL };
797 DBusBabysitter *sitter;
798 DBusError error;
799
800 sitter = NULL;
801
802 dbus_error_init (&error);
803
804 /*** Test launching nonexistent binary */
805
806 argv[0] = "/this/does/not/exist/32542sdgafgafdg";
807 if (_dbus_spawn_async_with_babysitter (&sitter, argv, NULL,
808 NULL, NULL,
809 &error))
810 {
811 _dbus_babysitter_block_for_child_exit (sitter);
812 _dbus_babysitter_set_child_exit_error (sitter, &error);
813 }
814
815 if (sitter)
816 _dbus_babysitter_unref (sitter);
817
818 if (!dbus_error_is_set (&error))
819 {
820 _dbus_warn ("Did not get an error launching nonexistent executable\n");
821 return FALSE;
822 }
823
824 if (!(dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY) ||
825 dbus_error_has_name (&error, DBUS_ERROR_SPAWN_EXEC_FAILED)))
826 {
827 _dbus_warn ("Not expecting error when launching nonexistent executable: %s: %s\n",
828 error.name, error.message);
829 dbus_error_free (&error);
830 return FALSE;
831 }
832
833 dbus_error_free (&error);
834
835 return TRUE;
836 }
837
838 static dbus_bool_t
check_spawn_segfault(void * data)839 check_spawn_segfault (void *data)
840 {
841 char *argv[4] = { NULL, NULL, NULL, NULL };
842 DBusBabysitter *sitter;
843 DBusError error;
844 DBusString argv0;
845
846 sitter = NULL;
847
848 dbus_error_init (&error);
849
850 /*** Test launching segfault binary */
851
852 argv[0] = get_test_exec ("test-segfault", &argv0);
853
854 if (argv[0] == NULL)
855 {
856 /* OOM was simulated, never mind */
857 return TRUE;
858 }
859
860 if (_dbus_spawn_async_with_babysitter (&sitter, argv, NULL,
861 NULL, NULL,
862 &error))
863 {
864 _dbus_babysitter_block_for_child_exit (sitter);
865 _dbus_babysitter_set_child_exit_error (sitter, &error);
866 }
867
868 _dbus_string_free (&argv0);
869
870 if (sitter)
871 _dbus_babysitter_unref (sitter);
872
873 if (!dbus_error_is_set (&error))
874 {
875 _dbus_warn ("Did not get an error launching segfaulting binary\n");
876 return FALSE;
877 }
878
879 if (!(dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY) ||
880 dbus_error_has_name (&error, DBUS_ERROR_SPAWN_CHILD_EXITED)))
881 {
882 _dbus_warn ("Not expecting error when launching segfaulting executable: %s: %s\n",
883 error.name, error.message);
884 dbus_error_free (&error);
885 return FALSE;
886 }
887
888 dbus_error_free (&error);
889
890 return TRUE;
891 }
892
893 static dbus_bool_t
check_spawn_exit(void * data)894 check_spawn_exit (void *data)
895 {
896 char *argv[4] = { NULL, NULL, NULL, NULL };
897 DBusBabysitter *sitter;
898 DBusError error;
899 DBusString argv0;
900
901 sitter = NULL;
902
903 dbus_error_init (&error);
904
905 /*** Test launching exit failure binary */
906
907 argv[0] = get_test_exec ("test-exit", &argv0);
908
909 if (argv[0] == NULL)
910 {
911 /* OOM was simulated, never mind */
912 return TRUE;
913 }
914
915 if (_dbus_spawn_async_with_babysitter (&sitter, argv, NULL,
916 NULL, NULL,
917 &error))
918 {
919 _dbus_babysitter_block_for_child_exit (sitter);
920 _dbus_babysitter_set_child_exit_error (sitter, &error);
921 }
922
923 _dbus_string_free (&argv0);
924
925 if (sitter)
926 _dbus_babysitter_unref (sitter);
927
928 if (!dbus_error_is_set (&error))
929 {
930 _dbus_warn ("Did not get an error launching binary that exited with failure code\n");
931 return FALSE;
932 }
933
934 if (!(dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY) ||
935 dbus_error_has_name (&error, DBUS_ERROR_SPAWN_CHILD_EXITED)))
936 {
937 _dbus_warn ("Not expecting error when launching exiting executable: %s: %s\n",
938 error.name, error.message);
939 dbus_error_free (&error);
940 return FALSE;
941 }
942
943 dbus_error_free (&error);
944
945 return TRUE;
946 }
947
948 static dbus_bool_t
check_spawn_and_kill(void * data)949 check_spawn_and_kill (void *data)
950 {
951 char *argv[4] = { NULL, NULL, NULL, NULL };
952 DBusBabysitter *sitter;
953 DBusError error;
954 DBusString argv0;
955
956 sitter = NULL;
957
958 dbus_error_init (&error);
959
960 /*** Test launching sleeping binary then killing it */
961
962 argv[0] = get_test_exec ("test-sleep-forever", &argv0);
963
964 if (argv[0] == NULL)
965 {
966 /* OOM was simulated, never mind */
967 return TRUE;
968 }
969
970 if (_dbus_spawn_async_with_babysitter (&sitter, argv, NULL,
971 NULL, NULL,
972 &error))
973 {
974 _dbus_babysitter_kill_child (sitter);
975
976 _dbus_babysitter_block_for_child_exit (sitter);
977
978 _dbus_babysitter_set_child_exit_error (sitter, &error);
979 }
980
981 _dbus_string_free (&argv0);
982
983 if (sitter)
984 _dbus_babysitter_unref (sitter);
985
986 if (!dbus_error_is_set (&error))
987 {
988 _dbus_warn ("Did not get an error after killing spawned binary\n");
989 return FALSE;
990 }
991
992 if (!(dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY) ||
993 dbus_error_has_name (&error, DBUS_ERROR_SPAWN_CHILD_EXITED)))
994 {
995 _dbus_warn ("Not expecting error when killing executable: %s: %s\n",
996 error.name, error.message);
997 dbus_error_free (&error);
998 return FALSE;
999 }
1000
1001 dbus_error_free (&error);
1002
1003 return TRUE;
1004 }
1005
1006 dbus_bool_t
_dbus_spawn_test(const char * test_data_dir)1007 _dbus_spawn_test (const char *test_data_dir)
1008 {
1009 if (!_dbus_test_oom_handling ("spawn_nonexistent",
1010 check_spawn_nonexistent,
1011 NULL))
1012 return FALSE;
1013
1014 /* Don't run the obnoxious segfault test by default,
1015 * it's a pain to have to click all those error boxes.
1016 */
1017 if (getenv ("DO_SEGFAULT_TEST"))
1018 if (!_dbus_test_oom_handling ("spawn_segfault",
1019 check_spawn_segfault,
1020 NULL))
1021 return FALSE;
1022
1023 if (!_dbus_test_oom_handling ("spawn_exit",
1024 check_spawn_exit,
1025 NULL))
1026 return FALSE;
1027
1028 if (!_dbus_test_oom_handling ("spawn_and_kill",
1029 check_spawn_and_kill,
1030 NULL))
1031 return FALSE;
1032
1033 return TRUE;
1034 }
1035 #endif
1036