Merge branch 'dbus-1.6'
[platform/upstream/dbus.git] / dbus / dbus-spawn-win.c
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_ENABLE_EMBEDDED_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*
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_ENABLE_EMBEDDED_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 *
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
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
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_ENABLE_EMBEDDED_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
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
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
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
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
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
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
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 *
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 *
530 build_commandline (char **argv)
531 {
532   return compose_string (argv, ' ');
533 }
534
535 static char *
536 build_env_string (char** envp)
537 {
538   return compose_string (envp, '\0');
539 }
540
541 static HANDLE
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
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_ENABLE_EMBEDDED_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
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
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_ENABLE_EMBEDDED_TESTS
757
758 static char *
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
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
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
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
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
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
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