| /* |
| * Copyright (C) 2011 Red Hat, Inc. |
| * |
| * This work is provided "as is"; redistribution and modification |
| * in whole or in part, in any medium, physical or electronic is |
| * permitted without restriction. |
| * |
| * This work is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| * |
| * In no event shall the authors or contributors be liable for any |
| * direct, indirect, incidental, special, exemplary, or consequential |
| * damages (including, but not limited to, procurement of substitute |
| * goods or services; loss of use, data, or profits; or business |
| * interruption) however caused and on any theory of liability, whether |
| * in contract, strict liability, or tort (including negligence or |
| * otherwise) arising in any way out of the use of this software, even |
| * if advised of the possibility of such damage. |
| * |
| * Author: Colin Walters <walters@verbum.org> |
| */ |
| |
| #include "config.h" |
| |
| #include "glib-unix.h" |
| #include <string.h> |
| |
| static void |
| test_pipe (void) |
| { |
| GError *error = NULL; |
| int pipefd[2]; |
| char buf[1024]; |
| ssize_t bytes_read; |
| gboolean res; |
| |
| res = g_unix_open_pipe (pipefd, FD_CLOEXEC, &error); |
| g_assert (res); |
| g_assert_no_error (error); |
| |
| write (pipefd[1], "hello", sizeof ("hello")); |
| memset (buf, 0, sizeof (buf)); |
| bytes_read = read (pipefd[0], buf, sizeof(buf) - 1); |
| g_assert_cmpint (bytes_read, >, 0); |
| buf[bytes_read] = '\0'; |
| |
| close (pipefd[0]); |
| close (pipefd[1]); |
| |
| g_assert (g_str_has_prefix (buf, "hello")); |
| } |
| |
| static void |
| test_error (void) |
| { |
| GError *error = NULL; |
| gboolean res; |
| |
| res = g_unix_set_fd_nonblocking (123456, TRUE, &error); |
| g_assert_cmpint (errno, ==, EBADF); |
| g_assert (!res); |
| g_assert_error (error, G_UNIX_ERROR, 0); |
| g_clear_error (&error); |
| } |
| |
| static gboolean sig_received = FALSE; |
| |
| static gboolean |
| on_sig_received (gpointer user_data) |
| { |
| GMainLoop *loop = user_data; |
| g_main_loop_quit (loop); |
| sig_received = TRUE; |
| return G_SOURCE_REMOVE; |
| } |
| |
| static gboolean |
| sig_not_received (gpointer data) |
| { |
| GMainLoop *loop = data; |
| (void) loop; |
| g_error ("Timed out waiting for signal"); |
| return G_SOURCE_REMOVE; |
| } |
| |
| static gboolean |
| exit_mainloop (gpointer data) |
| { |
| GMainLoop *loop = data; |
| g_main_loop_quit (loop); |
| return G_SOURCE_REMOVE; |
| } |
| |
| static void |
| test_signal (int signum) |
| { |
| GMainLoop *mainloop; |
| int id; |
| |
| mainloop = g_main_loop_new (NULL, FALSE); |
| |
| sig_received = FALSE; |
| g_unix_signal_add (signum, on_sig_received, mainloop); |
| kill (getpid (), signum); |
| g_assert (!sig_received); |
| id = g_timeout_add (5000, sig_not_received, mainloop); |
| g_main_loop_run (mainloop); |
| g_assert (sig_received); |
| sig_received = FALSE; |
| g_source_remove (id); |
| |
| /* Ensure we don't get double delivery */ |
| g_timeout_add (500, exit_mainloop, mainloop); |
| g_main_loop_run (mainloop); |
| g_assert (!sig_received); |
| g_main_loop_unref (mainloop); |
| |
| } |
| |
| static void |
| test_sighup (void) |
| { |
| test_signal (SIGHUP); |
| } |
| |
| static void |
| test_sigterm (void) |
| { |
| test_signal (SIGTERM); |
| } |
| |
| static void |
| test_sighup_add_remove (void) |
| { |
| GMainLoop *mainloop; |
| guint id; |
| |
| mainloop = g_main_loop_new (NULL, FALSE); |
| |
| sig_received = FALSE; |
| id = g_unix_signal_add (SIGHUP, on_sig_received, mainloop); |
| g_source_remove (id); |
| kill (getpid (), SIGHUP); |
| g_assert (!sig_received); |
| g_main_loop_unref (mainloop); |
| |
| } |
| |
| typedef struct { |
| GPid regular_pid; |
| GPid catchall_pid; |
| GMainLoop *loop; |
| gboolean regular_exited; |
| gboolean catchall_exited; |
| } CatchAllData; |
| |
| static void |
| on_catchall_child (GPid pid, |
| gint estatus, |
| gpointer user_data) |
| { |
| CatchAllData *data = user_data; |
| GError *local_error = NULL; |
| GError **error = &local_error; |
| |
| g_assert (pid == data->catchall_pid); |
| |
| g_spawn_check_exit_status (estatus, error); |
| g_assert_no_error (local_error); |
| |
| data->catchall_exited = TRUE; |
| if (data->regular_exited) |
| g_main_loop_quit (data->loop); |
| } |
| |
| static void |
| on_regular_child (GPid pid, |
| gint estatus, |
| gpointer user_data) |
| { |
| CatchAllData *data = user_data; |
| GError *local_error = NULL; |
| GError **error = &local_error; |
| |
| g_assert (pid == data->regular_pid); |
| |
| g_spawn_check_exit_status (estatus, error); |
| g_assert_no_error (local_error); |
| |
| data->regular_exited = TRUE; |
| if (data->catchall_exited) |
| g_main_loop_quit (data->loop); |
| } |
| |
| static void |
| spawn_with_raw_fork (gchar **child_argv, |
| pid_t *out_pid) |
| { |
| pid_t pid; |
| |
| pid = fork (); |
| g_assert (pid >= 0); |
| if (pid == 0) |
| { |
| execv (child_argv[0], child_argv+1); |
| g_assert_not_reached (); |
| } |
| else |
| *out_pid = pid; |
| } |
| |
| static void |
| test_catchall (void) |
| { |
| GMainLoop *mainloop; |
| CatchAllData data; |
| GSource *source; |
| GPid pid; |
| GError *local_error = NULL; |
| GError **error = &local_error; |
| char *child_args[] = { "/bin/true", "/bin/true", NULL }; |
| |
| memset (&data, 0, sizeof (data)); |
| mainloop = g_main_loop_new (NULL, FALSE); |
| data.loop = mainloop; |
| |
| source = g_child_watch_source_new (-1); |
| g_source_set_callback (source, (GSourceFunc)on_catchall_child, &data, NULL); |
| g_source_attach (source, NULL); |
| g_source_unref (source); |
| |
| g_spawn_async (NULL, (char**)child_args, NULL, G_SPAWN_DO_NOT_REAP_CHILD, |
| NULL, NULL, &pid, error); |
| g_child_watch_add (pid, on_regular_child, &data); |
| data.regular_pid = pid; |
| |
| spawn_with_raw_fork ((char**)child_args, &pid); |
| data.catchall_pid = pid; |
| |
| g_main_loop_run (mainloop); |
| |
| g_source_destroy (source); |
| g_main_loop_unref (mainloop); |
| |
| g_assert (data.regular_exited && data.catchall_exited); |
| } |
| |
| int |
| main (int argc, |
| char *argv[]) |
| { |
| g_test_init (&argc, &argv, NULL); |
| |
| g_test_add_func ("/glib-unix/pipe", test_pipe); |
| g_test_add_func ("/glib-unix/error", test_error); |
| g_test_add_func ("/glib-unix/sighup", test_sighup); |
| g_test_add_func ("/glib-unix/sigterm", test_sigterm); |
| g_test_add_func ("/glib-unix/sighup_again", test_sighup); |
| g_test_add_func ("/glib-unix/sighup_add_remove", test_sighup_add_remove); |
| g_test_add_func ("/glib-unix/catchall", test_catchall); |
| |
| return g_test_run(); |
| } |