diff options
Diffstat (limited to 'src')
47 files changed, 1709 insertions, 2225 deletions
diff --git a/src/Makefile.am b/src/Makefile.am index a9e6eb17..c535f21c 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -1,4 +1,4 @@ -SUBDIRS = libply libply-splash-core libply-splash-graphics . plugins client viewer tests +SUBDIRS = libply libply-splash-core libply-splash-graphics . plugins client viewer if ENABLE_UPSTART_MONITORING SUBDIRS += upstart-bridge endif @@ -15,12 +15,13 @@ plymouthdbindir = $(plymouthdaemondir) plymouthdbin_PROGRAMS = plymouthd plymouthd_CFLAGS = $(PLYMOUTH_CFLAGS) \ + $(UDEV_CFLAGS) \ -DPLYMOUTH_PLUGIN_PATH=\"$(PLYMOUTH_PLUGIN_PATH)\" \ -DPLYMOUTH_THEME_PATH=\"$(PLYMOUTH_THEME_PATH)/\" \ -DPLYMOUTH_POLICY_DIR=\"$(PLYMOUTH_POLICY_DIR)/\" \ -DPLYMOUTH_RUNTIME_DIR=\"$(PLYMOUTH_RUNTIME_DIR)\" \ -DPLYMOUTH_CONF_DIR=\"$(PLYMOUTH_CONF_DIR)/\" -plymouthd_LDADD = $(PLYMOUTH_LIBS) libply/libply.la libply-splash-core/libply-splash-core.la +plymouthd_LDADD = $(PLYMOUTH_LIBS) $(UDEV_LIBS) libply/libply.la libply-splash-core/libply-splash-core.la plymouthd_SOURCES = \ ply-boot-protocol.h \ ply-boot-server.h \ diff --git a/src/client/Makefile.am b/src/client/Makefile.am index 9487901b..ead574a9 100644 --- a/src/client/Makefile.am +++ b/src/client/Makefile.am @@ -1,5 +1,3 @@ -SUBDIRS = . tests - INCLUDES = -I$(top_srcdir) \ -I$(top_srcdir)/src \ -I$(top_srcdir)/src/libply \ diff --git a/src/client/ply-boot-client.c b/src/client/ply-boot-client.c index 56458ceb..3480676a 100644 --- a/src/client/ply-boot-client.c +++ b/src/client/ply-boot-client.c @@ -869,137 +869,4 @@ ply_boot_client_attach_to_event_loop (ply_boot_client_t *client, } -#ifdef PLY_BOOT_CLIENT_ENABLE_TEST - -#include <stdio.h> - -#include "ply-event-loop.h" -#include "ply-boot-client.h" - -static void -on_pinged (ply_event_loop_t *loop) -{ - printf ("PING!\n"); -} - -static void -on_ping_failed (ply_event_loop_t *loop) -{ - printf ("PING FAILED! %m\n"); - ply_event_loop_exit (loop, 1); -} - -static void -on_update (ply_event_loop_t *loop) -{ - printf ("UPDATE!\n"); -} - -static void -on_update_failed (ply_event_loop_t *loop) -{ - printf ("UPDATE FAILED! %m\n"); - ply_event_loop_exit (loop, 1); -} - -static void -on_newroot (ply_event_loop_t *loop) -{ - printf ("NEWROOT!\n"); -} - -static void -on_system_initialized (ply_event_loop_t *loop) -{ - printf ("SYSTEM INITIALIZED!\n"); -} - -static void -on_system_initialized_failed (ply_event_loop_t *loop) -{ - printf ("SYSTEM INITIALIZATION REQUEST FAILED!\n"); - ply_event_loop_exit (loop, 1); -} - -static void -on_quit (ply_event_loop_t *loop) -{ - printf ("QUIT!\n"); - ply_event_loop_exit (loop, 0); -} - -static void -on_quit_failed (ply_event_loop_t *loop) -{ - printf ("QUIT FAILED! %m\n"); - ply_event_loop_exit (loop, 2); -} - -static void -on_disconnect (ply_event_loop_t *loop) -{ - printf ("DISCONNECT!\n"); - ply_event_loop_exit (loop, 1); -} - -int -main (int argc, - char **argv) -{ - ply_event_loop_t *loop; - ply_boot_client_t *client; - int exit_code; - - exit_code = 0; - - loop = ply_event_loop_new (); - - client = ply_boot_client_new (); - - if (!ply_boot_client_connect (client, - (ply_boot_client_disconnect_handler_t) on_disconnect, - loop)) - { - perror ("could not start boot client"); - return errno; - } - - ply_boot_client_attach_to_event_loop (client, loop); - ply_boot_client_ping_daemon (client, - (ply_boot_client_response_handler_t) on_pinged, - (ply_boot_client_response_handler_t) on_ping_failed, - loop); - - ply_boot_client_update_daemon (client, - "loading", - (ply_boot_client_response_handler_t) on_update, - (ply_boot_client_response_handler_t) on_update_failed, - loop); - - ply_boot_client_update_daemon (client, - "loading more", - (ply_boot_client_response_handler_t) on_update, - (ply_boot_client_response_handler_t) on_update_failed, - loop); - - ply_boot_client_tell_daemon_system_is_initialized (client, - (ply_boot_client_response_handler_t) - on_system_initialized, - (ply_boot_client_response_handler_t) - on_system_initialized_failed, - loop); - - ply_boot_client_tell_daemon_to_quit (client, - (ply_boot_client_response_handler_t) on_quit, - (ply_boot_client_response_handler_t) on_quit_failed, - loop); - - exit_code = ply_event_loop_run (loop); - - ply_boot_client_free (client); - - return exit_code; -} - -#endif /* PLY_BOOT_CLIENT_ENABLE_TEST */ /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/client/tests/Makefile.am b/src/client/tests/Makefile.am deleted file mode 100644 index c6dbfdbd..00000000 --- a/src/client/tests/Makefile.am +++ /dev/null @@ -1,10 +0,0 @@ -INCLUDES = \ - -I$(top_srcdir) \ - -I$(srcdir)/.. \ - -I$(srcdir)/../.. \ - -I$(srcdir) -TESTS = - -noinst_PROGRAMS = $(TESTS) - -MAINTAINERCLEANFILES = Makefile.in diff --git a/src/client/tests/ply-boot-client-test.am b/src/client/tests/ply-boot-client-test.am deleted file mode 100644 index f733032f..00000000 --- a/src/client/tests/ply-boot-client-test.am +++ /dev/null @@ -1,16 +0,0 @@ -TESTS += ply-boot-client-test - -ply_boot_client_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_BOOT_CLIENT_ENABLE_TEST -ply_boot_client_test_LDADD = $(PLYMOUTH_LIBS) - -ply_boot_client_test_SOURCES = \ - $(srcdir)/../ply-utils.h \ - $(srcdir)/../ply-utils.c \ - $(srcdir)/../ply-logger.h \ - $(srcdir)/../ply-logger.c \ - $(srcdir)/../ply-list.h \ - $(srcdir)/../ply-list.c \ - $(srcdir)/../ply-event-loop.h \ - $(srcdir)/../ply-event-loop.c \ - $(srcdir)/../ply-boot-client.h \ - $(srcdir)/../ply-boot-client.c diff --git a/src/libply-splash-core/Makefile.am b/src/libply-splash-core/Makefile.am index 1758556a..287b11b2 100644 --- a/src/libply-splash-core/Makefile.am +++ b/src/libply-splash-core/Makefile.am @@ -15,11 +15,13 @@ libply_splash_coredir = $(includedir)/plymouth-1/ply-splash-core libply_splash_core_HEADERS = \ ply-boot-splash.h \ ply-boot-splash-plugin.h \ + ply-device-manager.h \ ply-keyboard.h \ ply-pixel-buffer.h \ ply-pixel-display.h \ ply-renderer.h \ ply-renderer-plugin.h \ + ply-seat.h \ ply-terminal.h \ ply-text-display.h \ ply-text-progress-bar.h \ @@ -36,6 +38,7 @@ libply_splash_core_la_LDFLAGS = -export-symbols-regex '^[^_].*' \ -no-undefined libply_splash_core_la_SOURCES = \ $(libply_splash_core_HEADERS) \ + ply-device-manager.c \ ply-keyboard.c \ ply-pixel-display.c \ ply-text-display.c \ @@ -44,6 +47,7 @@ libply_splash_core_la_SOURCES = \ ply-terminal.c \ ply-pixel-buffer.c \ ply-renderer.c \ + ply-seat.c \ ply-boot-splash.c MAINTAINERCLEANFILES = Makefile.in diff --git a/src/libply-splash-core/ply-boot-splash.c b/src/libply-splash-core/ply-boot-splash.c index 93d93450..160ce45e 100644 --- a/src/libply-splash-core/ply-boot-splash.c +++ b/src/libply-splash-core/ply-boot-splash.c @@ -48,10 +48,6 @@ #define UPDATES_PER_SECOND 30 #endif -#define KEY_CTRL_L ('\100' ^'L') -#define KEY_CTRL_T ('\100' ^'T') -#define KEY_CTRL_V ('\100' ^'V') - struct _ply_boot_splash { ply_event_loop_t *loop; @@ -59,11 +55,9 @@ struct _ply_boot_splash const ply_boot_splash_plugin_interface_t *plugin_interface; ply_boot_splash_plugin_t *plugin; ply_boot_splash_mode_t mode; - ply_keyboard_t *keyboard; ply_buffer_t *boot_buffer; ply_trigger_t *idle_trigger; - ply_list_t *pixel_displays; - ply_list_t *text_displays; + ply_list_t *seats; char *theme_path; char *plugin_dir; @@ -100,18 +94,30 @@ ply_boot_splash_new (const char *theme_path, splash->mode = PLY_BOOT_SPLASH_MODE_INVALID; splash->boot_buffer = boot_buffer; - splash->pixel_displays = ply_list_new (); - splash->text_displays = ply_list_new (); + splash->seats = ply_list_new (); return splash; } static void -refresh_displays (ply_boot_splash_t *splash) +detach_from_seat (ply_boot_splash_t *splash, + ply_seat_t *seat) { - ply_list_node_t *node; + ply_keyboard_t *keyboard; + ply_list_t *displays; + ply_list_node_t *node, *next_node; - node = ply_list_get_first_node (splash->pixel_displays); + ply_trace ("removing keyboard"); + if (splash->plugin_interface->unset_keyboard != NULL) + { + keyboard = ply_seat_get_keyboard (seat); + splash->plugin_interface->unset_keyboard (splash->plugin, keyboard); + } + + ply_trace ("removing pixel displays"); + displays = ply_seat_get_pixel_displays (seat); + + node = ply_list_get_first_node (displays); while (node != NULL) { ply_pixel_display_t *display; @@ -119,184 +125,137 @@ refresh_displays (ply_boot_splash_t *splash) unsigned long width, height; display = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (splash->pixel_displays, node); + next_node = ply_list_get_next_node (displays, node); width = ply_pixel_display_get_width (display); height = ply_pixel_display_get_height (display); - ply_pixel_display_draw_area (display, 0, 0, width, height); + ply_trace ("Removing %lux%lu pixel display", width, height); + + if (splash->plugin_interface->remove_pixel_display != NULL) + splash->plugin_interface->remove_pixel_display (splash->plugin, display); + node = next_node; } - node = ply_list_get_first_node (splash->text_displays); + ply_trace ("removing text displays"); + displays = ply_seat_get_text_displays (seat); + + node = ply_list_get_first_node (displays); while (node != NULL) { ply_text_display_t *display; - ply_list_node_t *next_node; int number_of_columns, number_of_rows; display = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (splash->text_displays, node); + next_node = ply_list_get_next_node (displays, node); number_of_columns = ply_text_display_get_number_of_columns (display); number_of_rows = ply_text_display_get_number_of_rows (display); - ply_text_display_draw_area (display, 0, 0, - number_of_columns, - number_of_rows); + ply_trace ("Removing %dx%d text display", number_of_columns, number_of_rows); + + if (splash->plugin_interface->remove_text_display != NULL) + splash->plugin_interface->remove_text_display (splash->plugin, display); + node = next_node; } } -static ply_terminal_t * -find_local_console_terminal (ply_boot_splash_t *splash) +static void +attach_to_seat (ply_boot_splash_t *splash, + ply_seat_t *seat) { - ply_list_node_t *node; - node = ply_list_get_first_node (splash->text_displays); + ply_keyboard_t *keyboard; + ply_list_t *displays; + ply_list_node_t *node, *next_node; - while (node != NULL) + if (splash->plugin_interface->set_keyboard != NULL) { - ply_text_display_t *display; - ply_terminal_t *terminal; - ply_list_node_t *next_node; + keyboard = ply_seat_get_keyboard (seat); + splash->plugin_interface->set_keyboard (splash->plugin, keyboard); + } - display = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (splash->text_displays, node); + if (splash->plugin_interface->add_pixel_display != NULL) + { + displays = ply_seat_get_pixel_displays (seat); - terminal = ply_text_display_get_terminal (display); + ply_trace ("adding pixel displays"); + node = ply_list_get_first_node (displays); + while (node != NULL) + { + ply_pixel_display_t *display; + ply_list_node_t *next_node; + unsigned long width, height; - if (terminal != NULL && ply_terminal_is_vt (terminal)) - return terminal; + display = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (displays, node); - node = next_node; - } + width = ply_pixel_display_get_width (display); + height = ply_pixel_display_get_height (display); - return NULL; -} + ply_trace ("Adding %lux%lu pixel display", width, height); -static void -on_keyboard_input (ply_boot_splash_t *splash, - const char *keyboard_input, - size_t character_size) -{ - wchar_t key; + splash->plugin_interface->add_pixel_display (splash->plugin, display); - if ((ssize_t) mbrtowc (&key, keyboard_input, character_size, NULL) > 0) - { - switch (key) - { - case KEY_CTRL_L: - refresh_displays (splash); - return; - - case KEY_CTRL_T: - ply_trace ("toggle text mode!"); - splash->should_force_text_mode = !splash->should_force_text_mode; - - if (ply_list_get_length (splash->pixel_displays) >= 1) - { - ply_terminal_t *terminal; - - terminal = find_local_console_terminal (splash); - - if (terminal != NULL) - { - if (splash->should_force_text_mode) - { - ply_terminal_set_mode (terminal, PLY_TERMINAL_MODE_TEXT); - ply_terminal_ignore_mode_changes (terminal, true); - } - else - ply_terminal_ignore_mode_changes (terminal, false); - } - } - ply_trace ("text mode toggled!"); - return; - - case KEY_CTRL_V: - ply_trace ("toggle verbose mode!"); - ply_toggle_tracing (); - ply_trace ("verbose mode toggled!"); - return; + node = next_node; } } -} -void -ply_boot_splash_set_keyboard (ply_boot_splash_t *splash, - ply_keyboard_t *keyboard) -{ - splash->keyboard = keyboard; + if (splash->plugin_interface->add_text_display != NULL) + { + displays = ply_seat_get_text_displays (seat); - ply_keyboard_add_input_handler (keyboard, - (ply_keyboard_input_handler_t) - on_keyboard_input, splash); + ply_trace ("adding text displays"); + node = ply_list_get_first_node (displays); + while (node != NULL) + { + ply_text_display_t *display; + int number_of_columns, number_of_rows; - if (splash->plugin_interface->set_keyboard == NULL) - return; + display = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (displays, node); - splash->plugin_interface->set_keyboard (splash->plugin, keyboard); -} + number_of_columns = ply_text_display_get_number_of_columns (display); + number_of_rows = ply_text_display_get_number_of_rows (display); -void -ply_boot_splash_unset_keyboard (ply_boot_splash_t *splash) -{ - ply_keyboard_remove_input_handler (splash->keyboard, - (ply_keyboard_input_handler_t) - on_keyboard_input); + ply_trace ("Adding %dx%d text display", number_of_columns, number_of_rows); - if (splash->plugin_interface->set_keyboard == NULL) - return; + splash->plugin_interface->add_text_display (splash->plugin, display); - splash->plugin_interface->unset_keyboard (splash->plugin, splash->keyboard); + node = next_node; + } + } } void -ply_boot_splash_add_pixel_display (ply_boot_splash_t *splash, - ply_pixel_display_t *display) +ply_boot_splash_attach_to_seat (ply_boot_splash_t *splash, + ply_seat_t *seat) { - ply_list_append_data (splash->pixel_displays, display); - - if (splash->plugin_interface->add_pixel_display == NULL) - return; - - splash->plugin_interface->add_pixel_display (splash->plugin, display); -} + ply_list_node_t *node; -void -ply_boot_splash_remove_pixel_display (ply_boot_splash_t *splash, - ply_pixel_display_t *display) -{ - ply_list_remove_data (splash->pixel_displays, display); + node = ply_list_find_node (splash->seats, seat); - if (splash->plugin_interface->remove_pixel_display == NULL) + if (node != NULL) return; - splash->plugin_interface->remove_pixel_display (splash->plugin, display); + ply_list_append_data (splash->seats, seat); + attach_to_seat (splash, seat); } void -ply_boot_splash_add_text_display (ply_boot_splash_t *splash, - ply_text_display_t *display) +ply_boot_splash_detach_from_seat (ply_boot_splash_t *splash, + ply_seat_t *seat) { - ply_list_append_data (splash->text_displays, display); + ply_list_node_t *node; - if (splash->plugin_interface->add_text_display == NULL) - return; + node = ply_list_find_node (splash->seats, seat); - splash->plugin_interface->add_text_display (splash->plugin, display); -} - -void -ply_boot_splash_remove_text_display (ply_boot_splash_t *splash, - ply_text_display_t *display) -{ - ply_list_remove_data (splash->text_displays, display); - - if (splash->plugin_interface->remove_pixel_display == NULL) + if (node == NULL) return; - splash->plugin_interface->remove_text_display (splash->plugin, display); + ply_list_remove_data (splash->seats, seat); + detach_from_seat (splash, seat); } bool @@ -432,56 +391,24 @@ ply_boot_splash_unload (ply_boot_splash_t *splash) } static void -remove_displays (ply_boot_splash_t *splash) +detach_from_seats (ply_boot_splash_t *splash) { - ply_list_node_t *node, *next_node; + ply_list_node_t *node; - ply_trace ("removing pixel displays"); + ply_trace ("detaching from seats"); - node = ply_list_get_first_node (splash->pixel_displays); + node = ply_list_get_first_node (splash->seats); while (node != NULL) { - ply_pixel_display_t *display; + ply_seat_t *seat; ply_list_node_t *next_node; - unsigned long width, height; - display = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (splash->pixel_displays, node); + seat = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (splash->seats, node); - width = ply_pixel_display_get_width (display); - height = ply_pixel_display_get_height (display); + detach_from_seat (splash, seat); - ply_trace ("Removing %lux%lu pixel display", width, height); - - if (splash->plugin_interface->remove_pixel_display != NULL) - splash->plugin_interface->remove_pixel_display (splash->plugin, display); - - ply_trace ("Removing node"); - ply_list_remove_node (splash->pixel_displays, node); - - node = next_node; - } - - ply_trace ("removing text displays"); - node = ply_list_get_first_node (splash->text_displays); - while (node != NULL) - { - ply_text_display_t *display; - int number_of_columns, number_of_rows; - - display = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (splash->text_displays, node); - - number_of_columns = ply_text_display_get_number_of_columns (display); - number_of_rows = ply_text_display_get_number_of_rows (display); - - ply_trace ("Removing %dx%d text display", number_of_columns, number_of_rows); - - if (splash->plugin_interface->remove_text_display != NULL) - splash->plugin_interface->remove_text_display (splash->plugin, display); - - ply_trace ("Removing node"); - ply_list_remove_node (splash->text_displays, node); + ply_list_remove_node (splash->seats, node); node = next_node; } @@ -508,9 +435,8 @@ ply_boot_splash_free (ply_boot_splash_t *splash) splash); } - remove_displays (splash); - ply_list_free (splash->pixel_displays); - ply_list_free (splash->text_displays); + detach_from_seats (splash); + ply_list_free (splash->seats); if (splash->module_handle != NULL) ply_boot_splash_unload (splash); @@ -676,16 +602,6 @@ ply_boot_splash_hide (ply_boot_splash_t *splash) splash->plugin_interface->hide_splash_screen (splash->plugin, splash->loop); - if (ply_list_get_length (splash->pixel_displays) >= 1) - { - ply_terminal_t *terminal; - - terminal = find_local_console_terminal (splash); - - if (terminal != NULL) - ply_terminal_set_mode (terminal, PLY_TERMINAL_MODE_TEXT); - } - splash->mode = PLY_BOOT_SPLASH_MODE_INVALID; if (splash->loop != NULL) @@ -820,148 +736,4 @@ ply_boot_splash_become_idle (ply_boot_splash_t *splash, splash->plugin_interface->become_idle (splash->plugin, splash->idle_trigger); } -#ifdef PLY_BOOT_SPLASH_ENABLE_TEST - -#include <stdio.h> - -#include "ply-event-loop.h" -#include "ply-boot-splash.h" - -typedef struct test_state test_state_t; -struct test_state { - ply_event_loop_t *loop; - ply_boot_splash_t *splash; - ply_buffer_t *buffer; -}; - -static void -on_timeout (ply_boot_splash_t *splash) -{ - ply_boot_splash_update_status (splash, "foo"); - ply_event_loop_watch_for_timeout (splash->loop, - 5.0, - (ply_event_loop_timeout_handler_t) - on_timeout, - splash); -} - -static void -on_quit (test_state_t *state) -{ - ply_boot_splash_hide (state->splash); - ply_event_loop_exit (state->loop, 0); -} - -static void -add_displays_to_splash_from_renderer (test_state_t *state, - ply_renderer_t *renderer) -{ - ply_list_t *heads; - ply_list_node_t *node; - - heads = ply_renderer_get_heads (renderer); - - node = ply_list_get_first_node (heads); - while (node != NULL) - { - ply_list_node_t *next_node; - ply_renderer_head_t *head; - ply_pixel_display_t *display; - - head = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (heads, node); - - display = ply_pixel_display_new (renderer, head); - - ply_boot_splash_add_pixel_display (state->splash, display); - - node = next_node; - } -} - -int -main (int argc, - char **argv) -{ - int exit_code; - test_state_t state; - char *tty_name; - const char *theme_path; - ply_text_display_t *text_display; - ply_renderer_t *renderer; - ply_terminal_t *terminal; - ply_keyboard_t *keyboard; - - exit_code = 0; - - state.loop = ply_event_loop_new (); - - if (argc > 1) - theme_path = argv[1]; - else - theme_path = PLYMOUTH_THEME_PATH "/fade-in/fade-in.plymouth"; - - if (argc > 2) - asprintf(&tty_name, "tty%s", argv[2]); - else - tty_name = strdup("tty0"); - - terminal = ply_terminal_new (tty_name); - - if (!ply_terminal_open (terminal)) - { - perror ("could not open tty"); - return errno; - } - - renderer = ply_renderer_new (NULL, terminal); - free(tty_name); - - if (!ply_renderer_open (renderer)) - { - perror ("could not open renderer /dev/fb"); - ply_renderer_free (renderer); - return errno; - } - - keyboard = ply_keyboard_new_for_renderer (renderer); - ply_keyboard_add_escape_handler (keyboard, - (ply_keyboard_escape_handler_t) on_quit, &state); - - state.buffer = ply_buffer_new (); - state.splash = ply_boot_splash_new (theme_path, PLYMOUTH_PLUGIN_PATH, state.buffer); - - if (!ply_boot_splash_load (state.splash)) - { - perror ("could not load splash screen"); - return errno; - } - - ply_boot_splash_set_keyboard (state.splash, keyboard); - add_displays_to_splash_from_renderer (&state, renderer); - - text_display = ply_text_display_new (terminal); - ply_boot_splash_add_text_display (state.splash, text_display); - - ply_boot_splash_attach_to_event_loop (state.splash, state.loop); - - if (!ply_boot_splash_show (state.splash, PLY_BOOT_SPLASH_MODE_BOOT_UP)) - { - perror ("could not show splash screen"); - return errno; - } - - ply_event_loop_watch_for_timeout (state.loop, - 1.0, - (ply_event_loop_timeout_handler_t) - on_timeout, - state.splash); - exit_code = ply_event_loop_run (state.loop); - ply_boot_splash_free (state.splash); - ply_buffer_free (state.buffer); - - return exit_code; -} - -#endif /* PLY_BOOT_SPLASH_ENABLE_TEST */ /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/libply-splash-core/ply-boot-splash.h b/src/libply-splash-core/ply-boot-splash.h index a79e9396..335039ba 100644 --- a/src/libply-splash-core/ply-boot-splash.h +++ b/src/libply-splash-core/ply-boot-splash.h @@ -33,10 +33,12 @@ #include "ply-pixel-display.h" #include "ply-text-display.h" #include "ply-progress.h" +#include "ply-seat.h" #include "ply-boot-splash-plugin.h" typedef struct _ply_boot_splash ply_boot_splash_t; +typedef struct _ply_seat ply_seat_t; typedef void (* ply_boot_splash_on_idle_handler_t) (void *user_data); @@ -48,17 +50,10 @@ ply_boot_splash_t *ply_boot_splash_new (const char * theme_path, bool ply_boot_splash_load (ply_boot_splash_t *splash); bool ply_boot_splash_load_built_in (ply_boot_splash_t *splash); void ply_boot_splash_unload (ply_boot_splash_t *splash); -void ply_boot_splash_set_keyboard (ply_boot_splash_t *splash, - ply_keyboard_t *keyboard); -void ply_boot_splash_unset_keyboard (ply_boot_splash_t *splash); -void ply_boot_splash_add_pixel_display (ply_boot_splash_t *splash, - ply_pixel_display_t *display); -void ply_boot_splash_remove_pixel_display (ply_boot_splash_t *splash, - ply_pixel_display_t *display); -void ply_boot_splash_add_text_display (ply_boot_splash_t *splash, - ply_text_display_t *display); -void ply_boot_splash_remove_text_display (ply_boot_splash_t *splash, - ply_text_display_t *display); +void ply_boot_splash_attach_to_seat (ply_boot_splash_t *splash, + ply_seat_t *seat); +void ply_boot_splash_detach_from_seat (ply_boot_splash_t *splash, + ply_seat_t *seat); void ply_boot_splash_free (ply_boot_splash_t *splash); bool ply_boot_splash_show (ply_boot_splash_t *splash, ply_boot_splash_mode_t mode); diff --git a/src/libply-splash-core/ply-device-manager.c b/src/libply-splash-core/ply-device-manager.c new file mode 100644 index 00000000..9a66988b --- /dev/null +++ b/src/libply-splash-core/ply-device-manager.c @@ -0,0 +1,771 @@ +/* ply-device-manager.c - device manager + * + * Copyright (C) 2013 Red Hat, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program 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. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + */ +#include "config.h" +#include "ply-device-manager.h" + +#include <assert.h> +#include <fcntl.h> +#include <stdbool.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <sys/stat.h> +#include <sys/types.h> + +#include <libudev.h> + +#include "ply-logger.h" +#include "ply-event-loop.h" +#include "ply-hashtable.h" +#include "ply-list.h" +#include "ply-utils.h" + +static void create_seat_for_terminal_and_renderer_type (ply_device_manager_t *manager, + const char *device_path, + ply_terminal_t *terminal, + ply_renderer_type_t renderer_type); +struct _ply_device_manager +{ + ply_device_manager_flags_t flags; + ply_event_loop_t *loop; + ply_hashtable_t *terminals; + ply_terminal_t *local_console_terminal; + ply_list_t *seats; + struct udev *udev_context; + struct udev_monitor *udev_monitor; + + ply_seat_added_handler_t seat_added_handler; + ply_seat_removed_handler_t seat_removed_handler; + void *seat_event_handler_data; +}; + +static void +detach_from_event_loop (ply_device_manager_t *manager) +{ + assert (manager != NULL); + + manager->loop = NULL; +} + +static void +attach_to_event_loop (ply_device_manager_t *manager, + ply_event_loop_t *loop) +{ + assert (manager != NULL); + assert (loop != NULL); + assert (manager->loop == NULL); + + manager->loop = loop; + + ply_event_loop_watch_for_exit (loop, (ply_event_loop_exit_handler_t) + detach_from_event_loop, + manager); +} + +static bool +device_is_for_local_console (ply_device_manager_t *manager, + struct udev_device *device) +{ + const char *device_path; + struct udev_device *bus_device; + char *bus_device_path; + const char *boot_vga; + bool for_local_console; + + /* Look at the associated bus device to see if this card is the + * card the kernel is using for its console. */ + device_path = udev_device_get_syspath (device); + asprintf (&bus_device_path, "%s/device", device_path); + bus_device = udev_device_new_from_syspath (manager->udev_context, bus_device_path); + + boot_vga = udev_device_get_sysattr_value (bus_device, "boot_vga"); + free (bus_device_path); + + if (boot_vga != NULL && strcmp (boot_vga, "1") == 0) + for_local_console = true; + else + for_local_console = false; + + return for_local_console; +} + +static char * +get_drm_device_node_path_from_fb_device (ply_device_manager_t *manager, + struct udev_device *fb_device) +{ + struct udev_enumerate *card_matches; + struct udev_list_entry *card_entry; + const char *id_path; + char *device_node_path = NULL; + + /* We want to see if the framebuffer is associated with a DRM-capable + * graphics card, if it is, we'll use the DRM device */ + card_matches = udev_enumerate_new (manager->udev_context); + udev_enumerate_add_match_is_initialized(card_matches); + udev_enumerate_add_match_parent (card_matches, udev_device_get_parent (fb_device)); + udev_enumerate_add_match_subsystem (card_matches, "drm"); + id_path = udev_device_get_property_value (fb_device, "ID_PATH"); + udev_enumerate_add_match_property (card_matches, "ID_PATH", id_path); + + udev_enumerate_scan_devices (card_matches); + + /* there should only ever be at most one match so we don't iterate through + * the list, but just look at the first entry */ + card_entry = udev_enumerate_get_list_entry (card_matches); + + if (card_entry != NULL) + { + struct udev_device *card_device = NULL; + const char *card_node; + const char *card_path; + + card_path = udev_list_entry_get_name (card_entry); + card_device = udev_device_new_from_syspath (manager->udev_context, card_path); + card_node = udev_device_get_devnode (card_device); + if (card_node != NULL) + device_node_path = strdup (card_node); + + udev_device_unref (card_device); + } + + udev_enumerate_unref (card_matches); + return device_node_path; +} + +static void +create_seat_for_udev_device (ply_device_manager_t *manager, + struct udev_device *device) +{ + bool for_local_console; + char *card_path; + ply_terminal_t *terminal = NULL; + + for_local_console = device_is_for_local_console (manager, device); + + if (for_local_console) + terminal = manager->local_console_terminal; + + card_path = get_drm_device_node_path_from_fb_device (manager, device); + + if (card_path != NULL) + { + create_seat_for_terminal_and_renderer_type (manager, + card_path, + terminal, + PLY_RENDERER_TYPE_DRM); + free (card_path); + } + else + { + const char *fb_device_node_path; + + fb_device_node_path = udev_device_get_devnode (device); + if (fb_device_node_path != NULL) + create_seat_for_terminal_and_renderer_type (manager, + fb_device_node_path, + terminal, + PLY_RENDERER_TYPE_FRAME_BUFFER); + } +} + +static void +free_seat_from_device_path (ply_device_manager_t *manager, + const char *device_path) +{ + ply_list_node_t *node; + + node = ply_list_get_first_node (manager->seats); + while (node != NULL) + { + ply_seat_t *seat; + ply_renderer_t *renderer; + ply_list_node_t *next_node; + const char *renderer_device_path; + + seat = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (manager->seats, node); + renderer = ply_seat_get_renderer (seat); + + if (renderer != NULL) + { + renderer_device_path = ply_renderer_get_device_name (renderer); + + if (renderer_device_path != NULL) + { + if (strcmp (device_path, renderer_device_path) == 0) + { + ply_trace ("removing seat associated with %s", device_path); + + if (manager->seat_removed_handler != NULL) + manager->seat_removed_handler (manager->seat_event_handler_data, seat); + + ply_seat_free (seat); + ply_list_remove_node (manager->seats, node); + break; + } + } + } + + node = next_node; + } +} + +static void +free_seat_for_udev_device (ply_device_manager_t *manager, + struct udev_device *device) +{ + char *card_path; + + card_path = get_drm_device_node_path_from_fb_device (manager, device); + + if (card_path != NULL) + { + free_seat_from_device_path (manager, card_path); + free (card_path); + } + else + { + const char *fb_device_node_path; + + fb_device_node_path = udev_device_get_devnode (device); + + if (fb_device_node_path != NULL) + free_seat_from_device_path (manager, fb_device_node_path); + } +} + +static void +scan_graphics_devices (ply_device_manager_t *manager) +{ + struct udev_enumerate *fb_matches; + struct udev_list_entry *fb_entry; + + ply_trace ("scanning for graphics devices"); + /* graphics subsystem is for /dev/fb devices. kms drivers provide /dev/fb for backward + * compatibility, and do so at the end of their initialization, so we can be confident + * that when this subsystem is available the drm device is fully initialized */ + fb_matches = udev_enumerate_new (manager->udev_context); + udev_enumerate_add_match_is_initialized(fb_matches); + udev_enumerate_add_match_subsystem (fb_matches, "graphics"); + + /* We only care about devices assigned to a (any) seat. Floating + * devices should be ignored. As a side-effect, this conveniently + * filters out the fbcon device which we don't care about. + */ + udev_enumerate_add_match_tag (fb_matches, "seat"); + udev_enumerate_scan_devices (fb_matches); + + udev_list_entry_foreach (fb_entry, udev_enumerate_get_list_entry (fb_matches)) + { + struct udev_device *fb_device = NULL; + const char *fb_node; + const char *fb_path; + + fb_path = udev_list_entry_get_name (fb_entry); + fb_device = udev_device_new_from_syspath (manager->udev_context, fb_path); + fb_node = udev_device_get_devnode (fb_device); + if (fb_node != NULL) + create_seat_for_udev_device (manager, fb_device); + + udev_device_unref (fb_device); + } + + udev_enumerate_unref (fb_matches); +} + +static void +on_udev_graphics_event (ply_device_manager_t *manager) +{ + struct udev_device *device; + const char *action; + + device = udev_monitor_receive_device (manager->udev_monitor); + if (device == NULL) + return; + + action = udev_device_get_action (device); + + if (action == NULL) + return; + + if (strcmp (action, "add") == 0) + create_seat_for_udev_device (manager, device); + else if (strcmp (action, "remove") == 0) + free_seat_for_udev_device (manager, device); + + udev_device_unref (device); +} + +static void +watch_for_udev_events (ply_device_manager_t *manager) +{ + int fd; + assert (manager != NULL); + assert (manager->udev_monitor == NULL); + + ply_trace ("watching for udev graphics device add and remove events"); + manager->udev_monitor = udev_monitor_new_from_netlink (manager->udev_context, "udev"); + + /* The filter matching here mimics the matching done in scan_graphics_devices. + * See the comments in that function, for an explanation of what we're doing. + */ + udev_monitor_filter_add_match_subsystem_devtype (manager->udev_monitor, "graphics", NULL); + udev_monitor_filter_add_match_tag (manager->udev_monitor, "seat"); + udev_monitor_enable_receiving (manager->udev_monitor); + + fd = udev_monitor_get_fd (manager->udev_monitor); + ply_event_loop_watch_fd (manager->loop, + fd, + PLY_EVENT_LOOP_FD_STATUS_HAS_DATA, + (ply_event_handler_t) + on_udev_graphics_event, + NULL, + manager); + +} + +static void +free_seats (ply_device_manager_t *manager) +{ + ply_list_node_t *node; + + ply_trace ("removing seats"); + node = ply_list_get_first_node (manager->seats); + while (node != NULL) + { + ply_seat_t *seat; + ply_list_node_t *next_node; + + seat = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (manager->seats, node); + + if (manager->seat_removed_handler != NULL) + manager->seat_removed_handler (manager->seat_event_handler_data, seat); + + ply_seat_free (seat); + ply_list_remove_node (manager->seats, node); + + node = next_node; + } +} + +static void +free_terminal (char *device, + ply_terminal_t *terminal, + ply_device_manager_t *manager) +{ + ply_hashtable_remove (manager->terminals, device); + + ply_terminal_close (terminal); + ply_terminal_free (terminal); +} + +static void +free_terminals (ply_device_manager_t *manager) +{ + ply_hashtable_foreach (manager->terminals, + (ply_hashtable_foreach_func_t *) + free_terminal, + manager); +} + +static ply_terminal_t * +get_terminal (ply_device_manager_t *manager, + const char *device_name) +{ + char *full_name = NULL; + ply_terminal_t *terminal; + + if (strncmp (device_name, "/dev/", strlen ("/dev/")) == 0) + full_name = strdup (device_name); + else + asprintf (&full_name, "/dev/%s", device_name); + + if (strcmp (full_name, "/dev/tty0") == 0 || + strcmp (full_name, "/dev/tty") == 0) + { + terminal = manager->local_console_terminal; + goto done; + } + + terminal = ply_hashtable_lookup (manager->terminals, full_name); + + if (terminal == NULL) + { + terminal = ply_terminal_new (full_name); + + ply_hashtable_insert (manager->terminals, + (void *) ply_terminal_get_name (terminal), + terminal); + } + +done: + free (full_name); + return terminal; +} + +ply_device_manager_t * +ply_device_manager_new (const char *default_tty, + ply_device_manager_flags_t flags) +{ + ply_device_manager_t *manager; + + manager = calloc (1, sizeof (ply_device_manager_t)); + manager->loop = NULL; + manager->terminals = ply_hashtable_new (ply_hashtable_string_hash, ply_hashtable_string_compare); + manager->local_console_terminal = ply_terminal_new (default_tty); + ply_hashtable_insert (manager->terminals, + (void *) ply_terminal_get_name (manager->local_console_terminal), + manager->local_console_terminal); + manager->seats = ply_list_new (); + manager->flags = flags; + + if (!(flags & PLY_DEVICE_MANAGER_FLAGS_IGNORE_UDEV)) + manager->udev_context = udev_new (); + + attach_to_event_loop (manager, ply_event_loop_get_default ()); + + return manager; +} + +void +ply_device_manager_free (ply_device_manager_t *manager) +{ + ply_trace ("freeing device manager"); + + if (manager == NULL) + return; + + free_seats (manager); + ply_list_free (manager->seats); + + free_terminals (manager); + ply_hashtable_free (manager->terminals); + + if (manager->udev_monitor != NULL) + udev_monitor_unref (manager->udev_monitor); + + if (manager->udev_context != NULL) + udev_unref (manager->udev_context); + + free (manager); +} + +static int +add_consoles_from_file (ply_device_manager_t *manager, + const char *path) +{ + int fd; + char contents[512] = ""; + ssize_t contents_length; + int num_consoles; + const char *remaining_file_contents; + + ply_trace ("opening %s", path); + fd = open (path, O_RDONLY); + + if (fd < 0) + { + ply_trace ("couldn't open it: %m"); + return 0; + } + + ply_trace ("reading file"); + contents_length = read (fd, contents, sizeof (contents) - 1); + + if (contents_length <= 0) + { + ply_trace ("couldn't read it: %m"); + close (fd); + return 0; + } + close (fd); + + remaining_file_contents = contents; + num_consoles = 0; + + while (remaining_file_contents < contents + contents_length) + { + char *console; + size_t console_length; + const char *console_device; + ply_terminal_t *terminal; + + /* Advance past any leading whitespace */ + remaining_file_contents += strspn (remaining_file_contents, " \n\t\v"); + + if (*remaining_file_contents == '\0') + { + /* There's nothing left after the whitespace, we're done */ + break; + } + + /* Find trailing whitespace and NUL terminate. If strcspn + * doesn't find whitespace, it gives us the length of the string + * until the next NUL byte, which we'll just overwrite with + * another NUL byte anyway. */ + console_length = strcspn (remaining_file_contents, " \n\t\v"); + console = strndup (remaining_file_contents, console_length); + + terminal = get_terminal (manager, console); + console_device = ply_terminal_get_name (terminal); + + free (console); + + ply_trace ("console %s found!", console_device); + num_consoles++; + + /* Move past the parsed console string, and the whitespace we + * may have found above. If we found a NUL above and not whitespace, + * then we're going to jump past the end of the buffer and the loop + * will terminate + */ + remaining_file_contents += console_length + 1; + } + + return num_consoles; +} + +static void +create_seat_for_terminal_and_renderer_type (ply_device_manager_t *manager, + const char *device_path, + ply_terminal_t *terminal, + ply_renderer_type_t renderer_type) +{ + ply_seat_t *seat; + + ply_trace ("creating seat for %s (renderer type: %u) (terminal: %s)", + device_path? : "", renderer_type, terminal? ply_terminal_get_name (terminal): "none"); + seat = ply_seat_new (terminal); + + if (!ply_seat_open (seat, renderer_type, device_path)) + { + ply_trace ("could not create seat"); + ply_seat_free (seat); + return; + } + + ply_list_append_data (manager->seats, seat); + + if (manager->seat_added_handler != NULL) + manager->seat_added_handler (manager->seat_event_handler_data, seat); +} + +static void +create_seat_for_terminal (const char *device_path, + ply_terminal_t *terminal, + ply_device_manager_t *manager) +{ + create_seat_for_terminal_and_renderer_type (manager, + device_path, + terminal, + PLY_RENDERER_TYPE_NONE); +} +static bool +create_seats_from_terminals (ply_device_manager_t *manager) +{ + int num_consoles; + bool seats_created; + + ply_trace ("checking for consoles"); + + if (manager->flags & PLY_DEVICE_MANAGER_FLAGS_IGNORE_SERIAL_CONSOLES) + { + num_consoles = 0; + ply_trace ("ignoring all consoles but default console because explicitly told to."); + } + else + { + num_consoles = add_consoles_from_file (manager, "/sys/class/tty/console/active"); + + if (num_consoles == 0) + ply_trace ("ignoring all consoles but default console because /sys/class/tty/console/active could not be read"); + } + + if (num_consoles > 1) + { + ply_trace ("serial consoles detected, managing them with details forced"); + ply_hashtable_foreach (manager->terminals, + (ply_hashtable_foreach_func_t *) + create_seat_for_terminal, + manager); + seats_created = true; + } + else if (num_consoles <= 1 && (manager->flags & PLY_DEVICE_MANAGER_FLAGS_IGNORE_UDEV)) + { + ply_trace ("udev disabled, managing seat right away"); + create_seat_for_terminal_and_renderer_type (manager, + ply_terminal_get_name (manager->local_console_terminal), + manager->local_console_terminal, + PLY_RENDERER_TYPE_AUTO); + seats_created = true; + } + else + { + ply_trace ("will manage seat when ready"); + seats_created = false; + } + + return seats_created; +} + +void +ply_device_manager_watch_seats (ply_device_manager_t *manager, + ply_seat_added_handler_t seat_added_handler, + ply_seat_removed_handler_t seat_removed_handler, + void *data) +{ + bool seats_created; + + manager->seat_added_handler = seat_added_handler; + manager->seat_removed_handler = seat_removed_handler; + manager->seat_event_handler_data = data; + + /* Try to create seats for each terminal device right away, if possible + */ + seats_created = create_seats_from_terminals (manager); + + /* In most cases, though, we need to create devices based on udev device topology + */ + if (!seats_created) + { + watch_for_udev_events (manager); + scan_graphics_devices (manager); + } +} + +bool +ply_device_manager_has_open_seats (ply_device_manager_t *manager) +{ + ply_list_node_t *node; + + node = ply_list_get_first_node (manager->seats); + while (node != NULL) + { + ply_seat_t *seat; + ply_list_node_t *next_node; + + seat = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (manager->seats, node); + + if (ply_seat_is_open (seat)) + return true; + + node = next_node; + } + + return false; +} + +ply_list_t * +ply_device_manager_get_seats (ply_device_manager_t *manager) +{ + return manager->seats; +} + +ply_terminal_t * +ply_device_manager_get_default_terminal (ply_device_manager_t *manager) +{ + return manager->local_console_terminal; +} + +void +ply_device_manager_activate_renderers (ply_device_manager_t *manager) +{ + ply_list_node_t *node; + + ply_trace ("activating renderers"); + node = ply_list_get_first_node (manager->seats); + while (node != NULL) + { + ply_seat_t *seat; + ply_list_node_t *next_node; + + seat = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (manager->seats, node); + + ply_seat_activate_renderer (seat); + + node = next_node; + } +} + +void +ply_device_manager_deactivate_renderers (ply_device_manager_t *manager) +{ + ply_list_node_t *node; + + ply_trace ("deactivating renderers"); + node = ply_list_get_first_node (manager->seats); + while (node != NULL) + { + ply_seat_t *seat; + ply_list_node_t *next_node; + + seat = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (manager->seats, node); + + ply_seat_deactivate_renderer (seat); + + node = next_node; + } +} + +void +ply_device_manager_activate_keyboards (ply_device_manager_t *manager) +{ + ply_list_node_t *node; + + ply_trace ("activating keyboards"); + node = ply_list_get_first_node (manager->seats); + while (node != NULL) + { + ply_seat_t *seat; + ply_list_node_t *next_node; + + seat = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (manager->seats, node); + + ply_seat_activate_keyboard (seat); + + node = next_node; + } +} + +void +ply_device_manager_deactivate_keyboards (ply_device_manager_t *manager) +{ + ply_list_node_t *node; + + ply_trace ("deactivating keyboards"); + node = ply_list_get_first_node (manager->seats); + while (node != NULL) + { + ply_seat_t *seat; + ply_list_node_t *next_node; + + seat = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (manager->seats, node); + + ply_seat_deactivate_keyboard (seat); + + node = next_node; + } +} diff --git a/src/libply-splash-core/ply-device-manager.h b/src/libply-splash-core/ply-device-manager.h new file mode 100644 index 00000000..d9c58e87 --- /dev/null +++ b/src/libply-splash-core/ply-device-manager.h @@ -0,0 +1,56 @@ +/* ply-device-manager.h - udev monitor + * + * Copyright (C) 2013 Red Hat, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program 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. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + */ +#ifndef PLY_DEVICE_MANAGER_H +#define PLY_DEVICE_MANAGER_H + +#include <stdbool.h> +#include "ply-seat.h" + +typedef enum +{ + PLY_DEVICE_MANAGER_FLAGS_NONE = 0, + PLY_DEVICE_MANAGER_FLAGS_IGNORE_SERIAL_CONSOLES = 1 << 0, + PLY_DEVICE_MANAGER_FLAGS_IGNORE_UDEV = 1 << 1 +} ply_device_manager_flags_t; + +typedef struct _ply_device_manager ply_device_manager_t; +typedef void (* ply_seat_added_handler_t) (void *, ply_seat_t *); +typedef void (* ply_seat_removed_handler_t) (void *, ply_seat_t *); + +#ifndef PLY_HIDE_FUNCTION_DECLARATIONS +ply_device_manager_t *ply_device_manager_new (const char *default_tty, + ply_device_manager_flags_t flags); +void ply_device_manager_watch_seats (ply_device_manager_t *manager, + ply_seat_added_handler_t seat_added_handler, + ply_seat_removed_handler_t seat_removed_handler, + void *data); +bool ply_device_manager_has_open_seats (ply_device_manager_t *manager); +ply_list_t *ply_device_manager_get_seats (ply_device_manager_t *manager); +void ply_device_manager_free (ply_device_manager_t *manager); +void ply_device_manager_activate_keyboards (ply_device_manager_t *manager); +void ply_device_manager_deactivate_keyboards (ply_device_manager_t *manager); +void ply_device_manager_activate_renderers (ply_device_manager_t *manager); +void ply_device_manager_deactivate_renderers (ply_device_manager_t *manager); +ply_terminal_t *ply_device_manager_get_default_terminal (ply_device_manager_t *manager); + +#endif + +#endif +/* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/libply-splash-core/ply-renderer.c b/src/libply-splash-core/ply-renderer.c index 3559e013..04a99cef 100644 --- a/src/libply-splash-core/ply-renderer.c +++ b/src/libply-splash-core/ply-renderer.c @@ -49,7 +49,7 @@ struct _ply_renderer const ply_renderer_plugin_interface_t *plugin_interface; ply_renderer_backend_t *backend; - char *plugin_path; + ply_renderer_type_t type; char *device_name; ply_terminal_t *terminal; @@ -63,16 +63,15 @@ typedef const ply_renderer_plugin_interface_t * static void ply_renderer_unload_plugin (ply_renderer_t *renderer); ply_renderer_t * -ply_renderer_new (const char *plugin_path, - const char *device_name, - ply_terminal_t *terminal) +ply_renderer_new (ply_renderer_type_t renderer_type, + const char *device_name, + ply_terminal_t *terminal) { ply_renderer_t *renderer; renderer = calloc (1, sizeof (struct _ply_renderer)); - if (plugin_path != NULL) - renderer->plugin_path = strdup (plugin_path); + renderer->type = renderer_type; if (device_name != NULL) renderer->device_name = strdup (device_name); @@ -95,10 +94,15 @@ ply_renderer_free (ply_renderer_t *renderer) } free (renderer->device_name); - free (renderer->plugin_path); free (renderer); } +const char * +ply_renderer_get_device_name (ply_renderer_t *renderer) +{ + return renderer->device_name; +} + static bool ply_renderer_load_plugin (ply_renderer_t *renderer, const char *module_path) @@ -258,29 +262,28 @@ ply_renderer_open (ply_renderer_t *renderer) { int i; - /* FIXME: at some point we may want to make this - * part more dynamic (so you don't have to edit this - * list to add a new renderer) - */ - const char *known_plugins[] = + struct { - PLYMOUTH_PLUGIN_PATH "renderers/x11.so", - PLYMOUTH_PLUGIN_PATH "renderers/drm.so", - PLYMOUTH_PLUGIN_PATH "renderers/frame-buffer.so", - NULL + ply_renderer_type_t type; + const char *path; + } known_plugins[] = + { + { PLY_RENDERER_TYPE_X11, PLYMOUTH_PLUGIN_PATH "renderers/x11.so" }, + { PLY_RENDERER_TYPE_DRM, PLYMOUTH_PLUGIN_PATH "renderers/drm.so" }, + { PLY_RENDERER_TYPE_FRAME_BUFFER, PLYMOUTH_PLUGIN_PATH "renderers/frame-buffer.so" }, + { PLY_RENDERER_TYPE_NONE, NULL } }; - if (renderer->plugin_path != NULL) + for (i = 0; known_plugins[i].type != PLY_RENDERER_TYPE_NONE; i++) { - return ply_renderer_open_plugin (renderer, renderer->plugin_path); + if (renderer->type == known_plugins[i].type || + renderer->type == PLY_RENDERER_TYPE_AUTO) + { + if (ply_renderer_open_plugin (renderer, known_plugins[i].path)) + return true; + } } - for (i = 0; known_plugins[i] != NULL; i++) - { - if (ply_renderer_open_plugin (renderer, known_plugins[i])) - return true; - } - ply_trace ("could not find suitable rendering plugin"); return false; } diff --git a/src/libply-splash-core/ply-renderer.h b/src/libply-splash-core/ply-renderer.h index 4b3bd1a3..3d483413 100644 --- a/src/libply-splash-core/ply-renderer.h +++ b/src/libply-splash-core/ply-renderer.h @@ -35,12 +35,21 @@ typedef struct _ply_renderer ply_renderer_t; typedef struct _ply_renderer_head ply_renderer_head_t; typedef struct _ply_renderer_input_source ply_renderer_input_source_t; +typedef enum +{ + PLY_RENDERER_TYPE_NONE = -1, + PLY_RENDERER_TYPE_AUTO, + PLY_RENDERER_TYPE_DRM, + PLY_RENDERER_TYPE_FRAME_BUFFER, + PLY_RENDERER_TYPE_X11 +} ply_renderer_type_t; + typedef void (* ply_renderer_input_source_handler_t) (void *user_data, ply_buffer_t *key_buffer, ply_renderer_input_source_t *input_source); #ifndef PLY_HIDE_FUNCTION_DECLARATIONS -ply_renderer_t *ply_renderer_new (const char *plugin_path, +ply_renderer_t *ply_renderer_new (ply_renderer_type_t renderer_type, const char *device_name, ply_terminal_t *terminal); void ply_renderer_free (ply_renderer_t *renderer); @@ -48,6 +57,7 @@ bool ply_renderer_open (ply_renderer_t *renderer); void ply_renderer_close (ply_renderer_t *renderer); void ply_renderer_activate (ply_renderer_t *renderer); void ply_renderer_deactivate (ply_renderer_t *renderer); +const char *ply_renderer_get_device_name (ply_renderer_t *renderer); ply_list_t *ply_renderer_get_heads (ply_renderer_t *renderer); ply_pixel_buffer_t *ply_renderer_get_buffer_for_head (ply_renderer_t *renderer, ply_renderer_head_t *head); diff --git a/src/libply-splash-core/ply-seat.c b/src/libply-splash-core/ply-seat.c new file mode 100644 index 00000000..d1493a71 --- /dev/null +++ b/src/libply-splash-core/ply-seat.c @@ -0,0 +1,365 @@ +/* ply-seat.c - APIs for encapsulating a keyboard and one or more displays + * + * Copyright (C) 2013 Red Hat, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program 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. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Written by: Ray Strode <rstrode@redhat.com> + */ +#include "config.h" +#include "ply-seat.h" + +#include <assert.h> +#include <errno.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> + +#include "ply-boot-splash.h" +#include "ply-event-loop.h" +#include "ply-keyboard.h" +#include "ply-pixel-display.h" +#include "ply-text-display.h" +#include "ply-list.h" +#include "ply-logger.h" +#include "ply-utils.h" + +struct _ply_seat +{ + ply_event_loop_t *loop; + + ply_boot_splash_t *splash; + ply_terminal_t *terminal; + ply_renderer_t *renderer; + ply_keyboard_t *keyboard; + ply_list_t *text_displays; + ply_list_t *pixel_displays; + + uint32_t renderer_active : 1; + uint32_t keyboard_active : 1; +}; + +ply_seat_t * +ply_seat_new (ply_terminal_t *terminal) +{ + ply_seat_t *seat; + + seat = calloc (1, sizeof (ply_seat_t)); + + seat->loop = ply_event_loop_get_default (); + seat->terminal = terminal; + seat->text_displays = ply_list_new (); + seat->pixel_displays = ply_list_new (); + + return seat; +} + +static void +add_pixel_displays (ply_seat_t *seat) +{ + ply_list_t *heads; + ply_list_node_t *node; + + heads = ply_renderer_get_heads (seat->renderer); + + ply_trace ("Adding displays for %d heads", + ply_list_get_length (heads)); + + node = ply_list_get_first_node (heads); + while (node != NULL) + { + ply_list_node_t *next_node; + ply_renderer_head_t *head; + ply_pixel_display_t *display; + + head = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (heads, node); + + display = ply_pixel_display_new (seat->renderer, head); + + ply_list_append_data (seat->pixel_displays, display); + + node = next_node; + } +} + +static void +add_text_displays (ply_seat_t *seat) +{ + ply_text_display_t *display; + + display = ply_text_display_new (seat->terminal); + ply_list_append_data (seat->text_displays, display); +} + +bool +ply_seat_open (ply_seat_t *seat, + ply_renderer_type_t renderer_type, + const char *device) +{ + if (renderer_type != PLY_RENDERER_TYPE_NONE) + { + ply_renderer_t *renderer; + + renderer = ply_renderer_new (renderer_type, device, seat->terminal); + + if (!ply_renderer_open (renderer) && renderer_type != PLY_RENDERER_TYPE_AUTO) + { + ply_trace ("could not open renderer for %s", device); + ply_renderer_free (renderer); + return false; + } + + seat->renderer = renderer; + seat->renderer_active = true; + } + + if (seat->renderer != NULL) + { + seat->keyboard = ply_keyboard_new_for_renderer (seat->renderer); + add_pixel_displays (seat); + + } + else + { + seat->keyboard = ply_keyboard_new_for_terminal (seat->terminal); + add_text_displays (seat); + } + seat->keyboard_active = true; + + return true; +} + +bool +ply_seat_is_open (ply_seat_t *seat) +{ + return ply_list_get_length (seat->pixel_displays) > 0 || + ply_list_get_length (seat->text_displays) > 0; +} + +void +ply_seat_deactivate_keyboard (ply_seat_t *seat) +{ + if (!seat->keyboard_active) + return; + + seat->keyboard_active = false; + + if (seat->keyboard == NULL) + return; + + ply_trace ("deactivating keybord"); + ply_keyboard_stop_watching_for_input (seat->keyboard); +} + +void +ply_seat_deactivate_renderer (ply_seat_t *seat) +{ + if (!seat->renderer_active) + return; + + seat->renderer_active = false; + + if (seat->renderer == NULL) + return; + + ply_trace ("deactivating renderer"); + ply_renderer_deactivate (seat->renderer); +} + +void +ply_seat_activate_keyboard (ply_seat_t *seat) +{ + if (seat->keyboard_active) + return; + + if (seat->keyboard == NULL) + return; + + ply_trace ("activating keyboard"); + ply_keyboard_watch_for_input (seat->keyboard); + + seat->keyboard_active = true; +} + +void +ply_seat_activate_renderer (ply_seat_t *seat) +{ + if (seat->renderer_active) + return; + + if (seat->renderer == NULL) + return; + + ply_trace ("activating renderer"); + ply_renderer_activate (seat->renderer); + + seat->renderer_active = true; +} + +void +ply_seat_refresh_displays (ply_seat_t *seat) +{ + ply_list_node_t *node; + + node = ply_list_get_first_node (seat->pixel_displays); + while (node != NULL) + { + ply_pixel_display_t *display; + ply_list_node_t *next_node; + unsigned long width, height; + + display = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (seat->pixel_displays, node); + + width = ply_pixel_display_get_width (display); + height = ply_pixel_display_get_height (display); + + ply_pixel_display_draw_area (display, 0, 0, width, height); + node = next_node; + } + + node = ply_list_get_first_node (seat->text_displays); + while (node != NULL) + { + ply_text_display_t *display; + ply_list_node_t *next_node; + int number_of_columns, number_of_rows; + + display = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (seat->text_displays, node); + + number_of_columns = ply_text_display_get_number_of_columns (display); + number_of_rows = ply_text_display_get_number_of_rows (display); + + ply_text_display_draw_area (display, 0, 0, + number_of_columns, + number_of_rows); + node = next_node; + } +} + +void +ply_seat_close (ply_seat_t *seat) +{ + if (seat->renderer == NULL) + return; + + ply_trace ("destroying renderer"); + ply_renderer_close (seat->renderer); + ply_renderer_free (seat->renderer); + seat->renderer = NULL; +} + +void +ply_seat_set_splash (ply_seat_t *seat, + ply_boot_splash_t *splash) +{ + if (seat->splash == splash) + return; + + if (seat->splash != NULL) + ply_boot_splash_detach_from_seat (splash, seat); + + if (splash != NULL) + ply_boot_splash_attach_to_seat (splash, seat); + + seat->splash = splash; +} + +static void +free_pixel_displays (ply_seat_t *seat) +{ + ply_list_node_t *node; + + ply_trace ("freeing %d pixel displays", ply_list_get_length (seat->pixel_displays)); + node = ply_list_get_first_node (seat->pixel_displays); + while (node != NULL) + { + ply_list_node_t *next_node; + ply_pixel_display_t *display; + + next_node = ply_list_get_next_node (seat->pixel_displays, node); + display = ply_list_node_get_data (node); + ply_pixel_display_free (display); + + ply_list_remove_node (seat->pixel_displays, node); + + node = next_node; + } +} + +static void +free_text_displays (ply_seat_t *seat) +{ + ply_list_node_t *node; + + ply_trace ("freeing %d text displays", ply_list_get_length (seat->text_displays)); + node = ply_list_get_first_node (seat->text_displays); + while (node != NULL) + { + ply_list_node_t *next_node; + ply_text_display_t *display; + + next_node = ply_list_get_next_node (seat->text_displays, node); + display = ply_list_node_get_data (node); + ply_text_display_free (display); + + ply_list_remove_node (seat->text_displays, node); + + node = next_node; + } +} + +void +ply_seat_free (ply_seat_t *seat) +{ + if (seat == NULL) + return; + + free_pixel_displays (seat); + free_text_displays (seat); + ply_keyboard_free (seat->keyboard); + + free (seat); +} + +ply_list_t * +ply_seat_get_pixel_displays (ply_seat_t *seat) +{ + return seat->pixel_displays; +} + +ply_list_t * +ply_seat_get_text_displays (ply_seat_t *seat) +{ + return seat->text_displays; +} + +ply_keyboard_t * +ply_seat_get_keyboard (ply_seat_t *seat) +{ + return seat->keyboard; +} + +ply_renderer_t * +ply_seat_get_renderer (ply_seat_t *seat) +{ + return seat->renderer; +} + +/* vim: set ts=4 sw=4 et ai ci cino={.5s,^-2,+.5s,t0,g0,e-2,n-2,p2s,(0,=.5s,:.5s */ diff --git a/src/libply-splash-core/ply-seat.h b/src/libply-splash-core/ply-seat.h new file mode 100644 index 00000000..d5d33978 --- /dev/null +++ b/src/libply-splash-core/ply-seat.h @@ -0,0 +1,66 @@ +/* ply-seat.h - APIs for encapsulating a keyboard and one or more displays + * + * Copyright (C) 2013 Red Hat, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program 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. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Written By: Ray Strode <rstrode@redhat.com> + */ +#ifndef PLY_SEAT_H +#define PLY_SEAT_H + +#include <stdarg.h> +#include <stdbool.h> +#include <stdint.h> +#include <unistd.h> + +#include "ply-boot-splash.h" +#include "ply-buffer.h" +#include "ply-event-loop.h" +#include "ply-keyboard.h" +#include "ply-list.h" +#include "ply-pixel-display.h" +#include "ply-terminal.h" +#include "ply-text-display.h" + +typedef struct _ply_boot_splash ply_boot_splash_t; +typedef struct _ply_seat ply_seat_t; + +#ifndef PLY_HIDE_FUNCTION_DECLARATIONS +ply_seat_t *ply_seat_new (ply_terminal_t *terminal); + +void ply_seat_free (ply_seat_t *seat); +bool ply_seat_open (ply_seat_t *seat, + ply_renderer_type_t renderer_type, + const char *device); +bool ply_seat_is_open (ply_seat_t *seat); +void ply_seat_deactivate_keyboard (ply_seat_t *seat); +void ply_seat_activate_keyboard (ply_seat_t *seat); +void ply_seat_deactivate_renderer (ply_seat_t *seat); +void ply_seat_activate_renderer (ply_seat_t *seat); +void ply_seat_refresh_displays (ply_seat_t *seat); +void ply_seat_close (ply_seat_t *seat); +void ply_seat_set_splash (ply_seat_t *seat, + ply_boot_splash_t *splash); + +ply_list_t *ply_seat_get_pixel_displays (ply_seat_t *seat); +ply_list_t *ply_seat_get_text_displays (ply_seat_t *seat); +ply_keyboard_t *ply_seat_get_keyboard (ply_seat_t *seat); +ply_renderer_t *ply_seat_get_renderer (ply_seat_t *seat); +#endif + +#endif /* PLY_SEAT_H */ +/* vim: set ts=4 sw=4 et ai ci cino={.5s,^-2,+.5s,t0,g0,e-2,n-2,p2s,(0,=.5s,:.5s */ diff --git a/src/libply-splash-core/ply-terminal.c b/src/libply-splash-core/ply-terminal.c index 2e95dc8c..992dd3f3 100644 --- a/src/libply-splash-core/ply-terminal.c +++ b/src/libply-splash-core/ply-terminal.c @@ -876,6 +876,12 @@ ply_terminal_free (ply_terminal_t *terminal) free (terminal); } +const char * +ply_terminal_get_name (ply_terminal_t *terminal) +{ + return terminal->name; +} + int ply_terminal_get_vt_number (ply_terminal_t *terminal) { diff --git a/src/libply-splash-core/ply-terminal.h b/src/libply-splash-core/ply-terminal.h index 8b4b0177..48b4f77f 100644 --- a/src/libply-splash-core/ply-terminal.h +++ b/src/libply-splash-core/ply-terminal.h @@ -91,6 +91,7 @@ void ply_terminal_set_mode (ply_terminal_t *terminal, void ply_terminal_ignore_mode_changes (ply_terminal_t *terminal, bool should_ignore); +const char *ply_terminal_get_name (ply_terminal_t *terminal); int ply_terminal_get_vt_number (ply_terminal_t *terminal); bool ply_terminal_activate_vt (ply_terminal_t *terminal); bool ply_terminal_deactivate_vt (ply_terminal_t *terminal); diff --git a/src/libply/Makefile.am b/src/libply/Makefile.am index 302e47d1..41b3a463 100644 --- a/src/libply/Makefile.am +++ b/src/libply/Makefile.am @@ -1,4 +1,3 @@ -SUBDIRS = tests INCLUDES = -I$(top_srcdir) \ -I$(srcdir) \ -DPLYMOUTH_TIME_DIRECTORY=\"$(localstatedir)/lib/plymouth/\" diff --git a/src/libply/ply-array.c b/src/libply/ply-array.c index 41134b86..999c86e5 100644 --- a/src/libply/ply-array.c +++ b/src/libply/ply-array.c @@ -171,34 +171,4 @@ ply_array_steal_uint32_elements (ply_array_t *array) return data; } -#ifdef PLY_ARRAY_ENABLE_TEST -#include <stdio.h> - -int -main (int argc, - char **argv) -{ - ply_array_t *array; - int i; - char **data; - - array = ply_array_new (PLY_ARRAY_ELEMENT_TYPE_POINTER); - - ply_array_add_pointer_element (array, "foo"); - ply_array_add_pointer_element (array, "bar"); - ply_array_add_pointer_element (array, "baz"); - ply_array_add_pointer_element (array, "qux"); - - data = (char **) ply_array_get_pointer_elements (array); - for (i = 0; data[i] != NULL; i++) - { - printf ("element '%d' has data '%s'\n", i, data[i]); - i++; - } - - ply_array_free (array); - return 0; -} - -#endif /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/libply/ply-bitarray.c b/src/libply/ply-bitarray.c index 89e22169..3d0cdd0c 100644 --- a/src/libply/ply-bitarray.c +++ b/src/libply/ply-bitarray.c @@ -42,64 +42,4 @@ ply_bitarray_count (ply_bitarray_t *bitarray, return count; } - - - -#ifdef PLY_BITARRAY_ENABLE_TEST -#include <stdio.h> - -int -main (int argc, - char **argv) -{ - ply_bitarray_t *bitarray; - int i, i2; - printf ("bitarray test start\n"); - bitarray = ply_bitarray_new (134); - - for (i=0; i<64; i++) - { - if (ply_bitarray_lookup (bitarray, i)) - printf ("1"); - else - printf ("0"); - } - printf ("\n"); - - for (i=0; i<64; i++) - if ((6654654654654654654ll >> i) & 1) - ply_bitarray_set (bitarray, i); - - for (i=0; i<64; i++) - { - if (ply_bitarray_lookup (bitarray, i)) - printf ("1"); - else - printf ("0"); - } - printf ("\n"); - - for (i = 63; i > 0; i--) - { - if ((6654654654654654654ll >> i) & 1) - { - ply_bitarray_clear (bitarray, i); - for (i2 = 0; i2 < 64; i2++) - { - if (ply_bitarray_lookup (bitarray, i2)) - printf ("1"); - else - printf ("0"); - } - printf ("\n"); - } - } - - ply_bitarray_free (bitarray); - - printf ("bitarray test end\n"); - return 0; -} - -#endif /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/libply/ply-buffer.c b/src/libply/ply-buffer.c index c65634f5..0d0406ff 100644 --- a/src/libply/ply-buffer.c +++ b/src/libply/ply-buffer.c @@ -263,22 +263,4 @@ ply_buffer_clear (ply_buffer_t *buffer) buffer->size = 0; } -#ifdef PLY_BUFFER_ENABLE_TEST -int -main (int argc, - char **argv) -{ - int exit_code; - ply_buffer_t *buffer; - - exit_code = 0; - buffer = ply_buffer_new (); - - ply_buffer_append (buffer, "yo yo yo\n"); - ply_buffer_free (buffer); - - return exit_code; -} - -#endif /* PLY_BUFFER_ENABLE_TEST */ /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/libply/ply-command-parser.c b/src/libply/ply-command-parser.c index 6ab323bc..2768668a 100644 --- a/src/libply/ply-command-parser.c +++ b/src/libply/ply-command-parser.c @@ -968,100 +968,4 @@ ply_command_parser_parse_arguments (ply_command_parser_t *parser, return parsed_arguments; } -#ifdef PLY_COMMAND_PARSER_ENABLE_TEST - -#include <stdio.h> - -#include "ply-command-parser.h" -#include "ply-event-loop.h" -#include "ply-logger.h" - -static void -on_ask_for_password (ply_command_parser_t *parser, - const char *command) -{ - char *prompt; - char *program; - - prompt = NULL; - program = NULL; - ply_command_parser_get_command_options (parser, command, "prompt", &prompt, "command", &program, NULL); - - printf ("ask for password with prompt '%s' feed result to '%s'\n", prompt, program); - free (prompt); - free (program); -} - -static void -on_show_splash (ply_command_parser_t *parser, - const char *command) -{ - char *plugin_name; - - plugin_name = NULL; - ply_command_parser_get_command_options (parser, command, "plugin-name", &plugin_name, NULL); - - printf ("show splash plugin '%s'\n", plugin_name); - free (plugin_name); -} - -int -main (int argc, - char **argv) -{ - ply_event_loop_t *loop; - ply_command_parser_t *parser; - bool should_help; - - loop = ply_event_loop_new (); - parser = ply_command_parser_new (argv[0], "Test Program"); - - ply_command_parser_add_options (parser, - "help", "This help message", PLY_COMMAND_OPTION_TYPE_FLAG, - NULL); - - ply_command_parser_add_command (parser, - "ask-for-password", - "Ask user for password", - (ply_command_handler_t) - on_ask_for_password, parser, - "command", "command to pipe result to", PLY_COMMAND_OPTION_TYPE_STRING, - "prompt", "string to present to user", PLY_COMMAND_OPTION_TYPE_STRING, - "output-result", "print result", PLY_COMMAND_OPTION_TYPE_BOOLEAN, - NULL); - - ply_command_parser_add_command (parser, - "show-splash", - "Show splash to user", - (ply_command_handler_t) - on_show_splash, parser, - "plugin-name", "name of the plugin to run", PLY_COMMAND_OPTION_TYPE_STRING, - NULL); - - if (!ply_command_parser_parse_arguments (parser, loop, argv, argc)) - { - ply_error ("couldn't parse arguments"); - return 1; - } - - - ply_command_parser_get_options (parser, "help", &should_help, NULL); - - if (should_help) - { - char *usage; - usage = ply_command_parser_get_help_string (parser); - printf ("%s\n", usage); - free (usage); - return 0; - } - - ply_event_loop_run (loop); - - ply_command_parser_free (parser); - - return 0; -} - -#endif /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/libply/ply-event-loop.c b/src/libply/ply-event-loop.c index 4abf25fc..0c85cb93 100644 --- a/src/libply/ply-event-loop.c +++ b/src/libply/ply-event-loop.c @@ -1376,88 +1376,4 @@ ply_event_loop_run (ply_event_loop_t *loop) return loop->exit_code; } -#ifdef PLY_EVENT_LOOP_ENABLE_TEST - -static ply_event_loop_t *loop; - -static void -alrm_signal_handler (void) -{ - write (1, "times up!\n", sizeof ("times up!\n") - 1); - ply_event_loop_exit (loop, 0); -} - -static void -usr1_signal_handler (void) -{ - write (1, "got sigusr1\n", sizeof ("got sigusr1\n") - 1); -} - -static void -hangup_signal_handler (void) -{ - write (1, "got hangup\n", sizeof ("got hangup\n") - 1); -} - -static void -terminate_signal_handler (void) -{ - write (1, "got terminate\n", sizeof ("got terminate\n") - 1); - ply_event_loop_exit (loop, 0); -} - -static void -line_received_handler (void) -{ - char line[512] = { 0 }; - printf ("Received line: "); - fflush (stdout); - - fgets (line, sizeof (line), stdin); - printf ("%s", line); -} - -static void -on_timeout (ply_event_loop_t *loop) -{ - printf ("timeout elapsed\n"); -} - -int -main (int argc, - char **argv) -{ - int exit_code; - - loop = ply_event_loop_new (); - - ply_event_loop_watch_signal (loop, SIGHUP, - (ply_event_handler_t) hangup_signal_handler, - NULL); - ply_event_loop_watch_signal (loop, SIGTERM, - (ply_event_handler_t) - terminate_signal_handler, NULL); - ply_event_loop_watch_signal (loop, SIGUSR1, - (ply_event_handler_t) - usr1_signal_handler, NULL); - ply_event_loop_watch_signal (loop, SIGALRM, - (ply_event_handler_t) - alrm_signal_handler, NULL); - - ply_event_loop_watch_for_timeout (loop, 2.0, - (ply_event_loop_timeout_handler_t) - on_timeout, loop); - ply_event_loop_watch_fd (loop, 0, PLY_EVENT_LOOP_FD_STATUS_HAS_DATA, - (ply_event_handler_t) line_received_handler, - (ply_event_handler_t) line_received_handler, - NULL); - - alarm (5); - exit_code = ply_event_loop_run (loop); - - ply_event_loop_free (loop); - - return exit_code; -} -#endif /* PLY_EVENT_LOOP_ENABLE_TEST */ /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/libply/ply-hashtable.c b/src/libply/ply-hashtable.c index 7d8d648e..7b03d876 100644 --- a/src/libply/ply-hashtable.c +++ b/src/libply/ply-hashtable.c @@ -130,14 +130,6 @@ ply_hashtable_insert_internal (ply_hashtable_t *hashtable, { unsigned int hash_index; int step = 0; - -#ifdef PLY_HASHTABLE_ENABLE_TEST - /* Make sure the counts are synchronised with bitmap */ - assert (ply_bitarray_count (hashtable->dirty_node_bitmap, hashtable->total_node_count) == - (int) hashtable->dirty_node_count); - assert (ply_bitarray_count (hashtable->live_node_bitmap, hashtable->total_node_count) == - (int) hashtable->live_node_count); -#endif /* PLY_HASHTABLE_ENABLE_TEST */ hash_index = hashtable->hash_func (key); hash_index &= hashtable->total_node_count - 1; @@ -281,56 +273,10 @@ ply_hashtable_foreach (ply_hashtable_t *hashtable, } } - -#ifdef PLY_HASHTABLE_ENABLE_TEST -#include <stdio.h> - -static void -foreach_func (void *key, - void *data, - void *user_data) -{ - printf ("foreach key:%s data:%s\n", (char*) key, (char*) data); -} - - int -main (int argc, - char **argv) +ply_hashtable_get_size (ply_hashtable_t *hashtable) { - ply_hashtable_t *hashtable; - int i; - const char* key[10] = {"k1", "k2", "k3", "k4", "k5", "k6", "k7", "k8", "k9", "k10"}; - const char* data[10] = {"d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10"}; - char* reply_key = NULL; - char* reply_data = NULL; - - printf ("hashtable test start\n"); - hashtable = ply_hashtable_new (ply_hashtable_string_hash, ply_hashtable_string_compare); - for (i=0; i<10; i++) - { - ply_hashtable_insert (hashtable, (void *) key[i], (void *) data[9-i]); - } - for (i=0; i<10; i++) - { - reply_data = ply_hashtable_lookup (hashtable, (void *) key[i]); - printf ("got:%s\n", reply_data); - } - for (i=0; i<10; i++) - { - ply_hashtable_remove (hashtable, (void *) key[i]); - ply_hashtable_insert (hashtable, (void *) key[i], (void *) data[i]); - } - for (i=0; i<10; i++) - { - if (ply_hashtable_lookup_full (hashtable, (void *) key[i], (void**) &reply_key, (void**) &reply_data)) - printf ("got key:%s data:%s\n", reply_key, reply_data); - } - ply_hashtable_foreach (hashtable, foreach_func, NULL); - ply_hashtable_free(hashtable); - printf ("hashtable test end\n"); - return 0; + return hashtable->live_node_count; } -#endif /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/libply/ply-hashtable.h b/src/libply/ply-hashtable.h index 016c781e..e7e1a6eb 100644 --- a/src/libply/ply-hashtable.h +++ b/src/libply/ply-hashtable.h @@ -57,6 +57,8 @@ int ply_hashtable_lookup_full (ply_hashtable_t *hashtable, void ply_hashtable_foreach (ply_hashtable_t *hashtable, ply_hashtable_foreach_func_t func, void *user_data); + +int ply_hashtable_get_size (ply_hashtable_t *hashtable); #endif #endif /* PLY_HASHTABLE_H */ diff --git a/src/libply/ply-list.c b/src/libply/ply-list.c index 85262ab6..8c589c21 100644 --- a/src/libply/ply-list.c +++ b/src/libply/ply-list.c @@ -375,85 +375,4 @@ ply_list_node_get_data (ply_list_node_t *node) return node->data; } -#ifdef PLY_LIST_ENABLE_TEST -#include <stdio.h> - -static int -compare_int_ptr (void *element_a, - void *element_b) -{ - int *int_a = element_a; - int *int_b = element_b; - return *int_a - *int_b; - -} - -int -main (int argc, - char **argv) -{ - ply_list_t *list; - ply_list_node_t *node; - int i, lastval; - int *value; - int errors; - - errors = 0; - - list = ply_list_new (); - - ply_list_append_data (list, (void *) "foo"); - ply_list_append_data (list, (void *) "bar"); - ply_list_append_data (list, (void *) "baz"); - ply_list_prepend_data (list, (void *) "qux"); - ply_list_prepend_data (list, (void *) "quux"); - ply_list_remove_data (list, (void *) "baz"); - ply_list_remove_data (list, (void *) "foo"); - - node = ply_list_get_first_node (list); - i = 0; - while (node != NULL) - { - printf ("node '%d' has data '%s'\n", i, - (char *) ply_list_node_get_data (node)); - node = ply_list_get_next_node (list, node); - i++; - } - - printf ("\n"); - ply_list_remove_all_nodes (list); - srandom(1); - - for (i = 0; i<100; i++) - { - value = malloc (sizeof (int)); - *value = random() % 100; - ply_list_append_data (list, (void *) value); - } - - ply_list_sort (list, compare_int_ptr); - - node = ply_list_get_first_node (list); - i = 0; - lastval = 0; - - while (node != NULL) - { - value = (int *) ply_list_node_get_data (node); - if (*value < lastval) - { - printf ("ERROR: incorrect order\n"); - errors = 1; - } - lastval = *value; - printf ("node '%d' has data '%d'\n", i, *value); - node = ply_list_get_next_node (list, node); - i++; - } - - ply_list_free (list); - return errors; -} - -#endif /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/libply/ply-logger.c b/src/libply/ply-logger.c index ec5b6e52..740c30ea 100644 --- a/src/libply/ply-logger.c +++ b/src/libply/ply-logger.c @@ -598,26 +598,4 @@ ply_logger_is_tracing_enabled (ply_logger_t *logger) } #endif /* PLY_ENABLE_TRACING */ -#ifdef PLY_LOGGER_ENABLE_TEST - -int -main (int argc, - char **argv) -{ - int exit_code; - ply_logger_t *logger; - - exit_code = 0; - logger = ply_logger_new (); - - ply_logger_inject (logger, "yo yo yo\n"); - ply_logger_set_output_fd (logger, 1); - ply_logger_inject (logger, "yo yo yo yo\n"); - ply_logger_flush (logger); - ply_logger_free (logger); - - return exit_code; -} - -#endif /* PLY_LOGGER_ENABLE_TEST */ /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/libply/ply-progress.c b/src/libply/ply-progress.c index cf372cdd..a88aa28b 100644 --- a/src/libply/ply-progress.c +++ b/src/libply/ply-progress.c @@ -330,75 +330,5 @@ ply_progress_status_update (ply_progress_t* progress, } } -#ifdef PLY_PROGRESS_ENABLE_TEST - -#include <stdio.h> - -int -main (int argc, - char **argv) -{ - double percent; - int slowness; - double time; - int i; - const char* strings[10]={"foobar", "barfoo", "barbar", "foo", "foo", "bar", "foo", "more", "even more", "even even more"}; - ply_progress_t* progress = ply_progress_new (); - - progress->scalar = 1.0/5; /* Original time estimate is 5 sec*/ - - percent = ply_progress_get_percentage (progress); - time = ply_progress_get_time (progress); - printf("Time:%f \t Percentage: %f%%\n", time, percent*100); - srand ((int) ply_get_timestamp ()); - - slowness = rand () % 500000 + 50000; - - for (i=0; i<2; i++) - { - usleep ((rand () % slowness+slowness)); - percent = ply_progress_get_percentage (progress); - time = ply_progress_get_time (progress); - printf("Time:%f \t Percentage: %f%%\n", time, percent*100); - } - printf("Load cache\n"); - ply_progress_load_cache (progress, PLYMOUTH_TIME_DIRECTORY "/boot-duration"); - - for (i=0; i<10; i++) - { - ply_progress_status_update (progress, strings[i]); - usleep ((rand () % slowness+slowness)); - percent = ply_progress_get_percentage (progress); - time = ply_progress_get_time (progress); - printf("Time:%f \t Percentage: %f%% \tScalar:%f\n", time, percent*100, progress->scalar); - } - printf("Save and free cache\n"); - ply_progress_save_cache (progress, PLYMOUTH_TIME_DIRECTORY "/boot-duration"); - ply_progress_free(progress); - - printf("\nManual set percentage run\n\n"); - - progress = ply_progress_new (); - progress->scalar = 1.0/5; /* Original time estimate is 5 sec*/ - - percent = ply_progress_get_percentage (progress); - time = ply_progress_get_time (progress); - printf("Time:%f \t Percentage: %f%%\n", time, percent*100); - srand ((int) ply_get_timestamp ()); - - for (i=0; i<12; i++) - { - ply_progress_set_percentage (progress, (double)i/12); - usleep ((rand () % slowness+slowness)); - percent = ply_progress_get_percentage (progress); - time = ply_progress_get_time (progress); - printf("Time:%f \t Percentage: %f%% (%f%%)\tScalar:%f\n", time, percent*100, (double)i/12*100, progress->scalar); - } - ply_progress_free(progress); - - return 0; -} - -#endif /* PLY_PROGRESS_ENABLE_TEST */ /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/libply/ply-region.c b/src/libply/ply-region.c index cbaca403..92d35743 100644 --- a/src/libply/ply-region.c +++ b/src/libply/ply-region.c @@ -467,141 +467,4 @@ ply_region_get_sorted_rectangle_list (ply_region_t *region) return region->rectangle_list; } -#ifdef PLY_REGION_ENABLE_TEST -#include <stdio.h> - -#define COVER_SIZE 100 -#define RECTANGLE_COUNT 1000 - -static void -cover_with_rect(char cover[COVER_SIZE][COVER_SIZE], - ply_rectangle_t *rectangle, - char value) -{ /* is value is not zero, the entry will be set to the value, - otherwise entry is incremented*/ - unsigned long x, y; - for (y=0; y<rectangle->height; y++) - { - for (x=0; x<rectangle->width; x++) - { - if (rectangle->x + x < COVER_SIZE && - rectangle->y + y < COVER_SIZE) - { - if (value) - cover[rectangle->y + y][rectangle->x + x] = value; - else - cover[rectangle->y + y][rectangle->x + x]++; - } - } - } -} - -static int -do_test (void) -{ - ply_rectangle_t rectangle; - char cover[COVER_SIZE][COVER_SIZE]; - int i; - unsigned long x, y; - ply_region_t *region; - ply_list_node_t *node; - - region = ply_region_new (); - - for (y = 0; y < COVER_SIZE; y++) - { - for (x = 0; x < COVER_SIZE; x++) - { - cover[y][x] = 0; - } - } - - for (i = 0; i < RECTANGLE_COUNT; i++) - { - rectangle.x = random() % COVER_SIZE-5; - rectangle.y = random() % COVER_SIZE-5; - rectangle.width = 1 + random() % 20; - rectangle.height = 1 + random() % 20; - printf("Adding X=%ld Y=%ld W=%ld H=%ld\n", - rectangle.x, - rectangle.y, - rectangle.width, - rectangle.height); - cover_with_rect(cover, &rectangle, 100); /* 100 means covered by origial squares */ - ply_region_add_rectangle (region, &rectangle); - } - - printf("Converted to:\n"); - int count = 0; - - ply_list_t *rectangle_list = ply_region_get_rectangle_list (region); - for (node = ply_list_get_first_node (rectangle_list); - node; - node = ply_list_get_next_node (rectangle_list, node)) - { - ply_rectangle_t *small_rectangle = ply_list_node_get_data (node); - printf("Processed X=%ld Y=%ld W=%ld H=%ld\n", - small_rectangle->x, - small_rectangle->y, - small_rectangle->width, - small_rectangle->height); - cover_with_rect(cover, small_rectangle, 0); - count++; - } - printf("Rectangles in:%d out:%d\n", RECTANGLE_COUNT, count); - - count=0; - - for (y = 0; y < COVER_SIZE; y++) - { - printf("%03ld ", y); - for (x = 0; x < COVER_SIZE; x++) - { - if (cover[y][x] >= 100) - { - if (cover[y][x] == 100) - { - printf("-"); /* "-" means should have been covered but wasn't */ - count++; - } - else - { - if (cover[y][x] == 101) - printf("O"); /* "O" means correctly covered */ - else - { - printf("%d", cover[y][x] - 101); - count++; /* 1+ means covered multiple times*/ - } - } - } - else - { - if (cover[y][x] == 0) - printf("o"); /* "o" means not involved*/ - else - { - printf("%c", 'A' - 1 + cover[y][x]); - count++; /* A+ means covered despite being not involved*/ - } - } - } - printf("\n"); - } - printf("errors:%d\n", count); - return count; -} -int -main (int argc, - char **argv) -{ - int i; - srandom(312); - for (i=0; i<100; i++) - { - if (do_test ()) return 1; - } - return 0; -} -#endif /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/libply/ply-terminal-session.c b/src/libply/ply-terminal-session.c index 0bdb985b..379035cc 100644 --- a/src/libply/ply-terminal-session.c +++ b/src/libply/ply-terminal-session.c @@ -587,57 +587,4 @@ ply_terminal_session_close_log (ply_terminal_session_t *session) return ply_logger_close_file (session->logger); } -#ifdef PLY_TERMINAL_SESSION_ENABLE_TEST - -#include <stdio.h> - -#include "ply-event-loop.h" -#include "ply-terminal-session.h" - -static void -on_finished (ply_event_loop_t *loop) -{ - ply_event_loop_exit (loop, 0); -} - -int -main (int argc, - char **argv) -{ - ply_event_loop_t *loop; - ply_terminal_session_t *session; - int exit_code; - ply_terminal_session_flags_t flags; - - exit_code = 0; - - loop = ply_event_loop_new (); - - session = ply_terminal_session_new ((const char * const *) (argv + 1)); - - flags = PLY_TERMINAL_SESSION_FLAGS_RUN_IN_PARENT; - flags |= PLY_TERMINAL_SESSION_FLAGS_LOOK_IN_PATH; - - ply_terminal_session_attach_to_event_loop (session, loop); - - if (!ply_terminal_session_run (session, flags, - (ply_terminal_session_begin_handler_t) NULL, - (ply_terminal_session_output_handler_t) NULL, - (ply_terminal_session_hangup_handler_t) - on_finished, loop)) - { - perror ("could not start terminal session"); - return errno; - } - - ply_terminal_session_open_log (session, "foo.log"); - - exit_code = ply_event_loop_run (loop); - - ply_terminal_session_free (session); - - return exit_code; -} - -#endif /* PLY_TERMINAL_SESSION_ENABLE_TEST */ /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/libply/tests/Makefile.am b/src/libply/tests/Makefile.am deleted file mode 100644 index bc4da58f..00000000 --- a/src/libply/tests/Makefile.am +++ /dev/null @@ -1,25 +0,0 @@ -INCLUDES = \ - -I$(top_srcdir) \ - -I$(srcdir)/.. \ - -I$(srcdir) -TESTS = - -if ENABLE_TESTS -include $(srcdir)/ply-terminal-session-test.am -include $(srcdir)/ply-logger-test.am -include $(srcdir)/ply-array-test.am -include $(srcdir)/ply-bitarray-test.am -include $(srcdir)/ply-list-test.am -include $(srcdir)/ply-hashtable-test.am -include $(srcdir)/ply-event-loop-test.am -include $(srcdir)/ply-command-parser-test.am -include $(srcdir)/ply-progress-test.am -include $(srcdir)/ply-region.am -endif - -noinst_PROGRAMS = $(TESTS) - -# Our tests aren't unit tests so clear for now -TESTS = - -MAINTAINERCLEANFILES = Makefile.in diff --git a/src/libply/tests/ply-array-test.am b/src/libply/tests/ply-array-test.am deleted file mode 100644 index 4f8ecc4e..00000000 --- a/src/libply/tests/ply-array-test.am +++ /dev/null @@ -1,16 +0,0 @@ -TESTS += ply-array-test - -ply_array_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_ARRAY_ENABLE_TEST -ply_array_test_LDADD = $(PLYMOUTH_LIBS) - -ply_array_test_SOURCES = \ - $(srcdir)/../ply-buffer.h \ - $(srcdir)/../ply-buffer.c \ - $(srcdir)/../ply-list.h \ - $(srcdir)/../ply-list.c \ - $(srcdir)/../ply-logger.h \ - $(srcdir)/../ply-logger.c \ - $(srcdir)/../ply-utils.h \ - $(srcdir)/../ply-utils.c \ - $(srcdir)/../ply-array.h \ - $(srcdir)/../ply-array.c diff --git a/src/libply/tests/ply-bitarray-test.am b/src/libply/tests/ply-bitarray-test.am deleted file mode 100644 index 85c36089..00000000 --- a/src/libply/tests/ply-bitarray-test.am +++ /dev/null @@ -1,8 +0,0 @@ -TESTS += ply-bitarray-test - -ply_bitarray_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_BITARRAY_ENABLE_TEST -ply_bitarray_test_LDADD = $(PLYMOUTH_LIBS) - -ply_bitarray_test_SOURCES = \ - $(srcdir)/../ply-bitarray.h \ - $(srcdir)/../ply-bitarray.c diff --git a/src/libply/tests/ply-command-parser-test.am b/src/libply/tests/ply-command-parser-test.am deleted file mode 100644 index 91649d5b..00000000 --- a/src/libply/tests/ply-command-parser-test.am +++ /dev/null @@ -1,18 +0,0 @@ -TESTS += ply-command-parser-test - -ply_command_parser_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_COMMAND_PARSER_ENABLE_TEST -ply_command_parser_test_LDADD = $(PLYMOUTH_LIBS) - -ply_command_parser_test_SOURCES = \ - $(srcdir)/../ply-buffer.h \ - $(srcdir)/../ply-buffer.c \ - $(srcdir)/../ply-event-loop.h \ - $(srcdir)/../ply-event-loop.c \ - $(srcdir)/../ply-list.h \ - $(srcdir)/../ply-list.c \ - $(srcdir)/../ply-logger.h \ - $(srcdir)/../ply-logger.c \ - $(srcdir)/../ply-utils.h \ - $(srcdir)/../ply-utils.c \ - $(srcdir)/../ply-command-parser.h \ - $(srcdir)/../ply-command-parser.c diff --git a/src/libply/tests/ply-event-loop-test.am b/src/libply/tests/ply-event-loop-test.am deleted file mode 100644 index c666ea6a..00000000 --- a/src/libply/tests/ply-event-loop-test.am +++ /dev/null @@ -1,14 +0,0 @@ -TESTS += ply-event-loop-test - -ply_event_loop_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_EVENT_LOOP_ENABLE_TEST -ply_event_loop_test_LDADD = $(PLYMOUTH_LIBS) - -ply_event_loop_test_SOURCES = \ - $(srcdir)/../ply-utils.h \ - $(srcdir)/../ply-utils.c \ - $(srcdir)/../ply-list.h \ - $(srcdir)/../ply-list.c \ - $(srcdir)/../ply-logger.h \ - $(srcdir)/../ply-logger.c \ - $(srcdir)/../ply-event-loop.h \ - $(srcdir)/../ply-event-loop.c diff --git a/src/libply/tests/ply-hashtable-test.am b/src/libply/tests/ply-hashtable-test.am deleted file mode 100644 index d3410fcd..00000000 --- a/src/libply/tests/ply-hashtable-test.am +++ /dev/null @@ -1,10 +0,0 @@ -TESTS += ply-hashtable-test - -ply_hashtable_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_HASHTABLE_ENABLE_TEST -ply_hashtable_test_LDADD = $(PLYMOUTH_LIBS) - -ply_hashtable_test_SOURCES = \ - $(srcdir)/../ply-hashtable.h \ - $(srcdir)/../ply-hashtable.c \ - $(srcdir)/../ply-bitarray.h \ - $(srcdir)/../ply-bitarray.c diff --git a/src/libply/tests/ply-list-test.am b/src/libply/tests/ply-list-test.am deleted file mode 100644 index 8beb5786..00000000 --- a/src/libply/tests/ply-list-test.am +++ /dev/null @@ -1,8 +0,0 @@ -TESTS += ply-list-test - -ply_list_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_LIST_ENABLE_TEST -ply_list_test_LDADD = $(PLYMOUTH_LIBS) - -ply_list_test_SOURCES = \ - $(srcdir)/../ply-list.h \ - $(srcdir)/../ply-list.c diff --git a/src/libply/tests/ply-logger-test.am b/src/libply/tests/ply-logger-test.am deleted file mode 100644 index a589fb92..00000000 --- a/src/libply/tests/ply-logger-test.am +++ /dev/null @@ -1,12 +0,0 @@ -TESTS += ply-logger-test - -ply_logger_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_LOGGER_ENABLE_TEST -ply_logger_test_LDADD = $(PLYMOUTH_LIBS) - -ply_logger_test_SOURCES = \ - $(srcdir)/../ply-list.h \ - $(srcdir)/../ply-list.c \ - $(srcdir)/../ply-utils.h \ - $(srcdir)/../ply-utils.c \ - $(srcdir)/../ply-logger.h \ - $(srcdir)/../ply-logger.c diff --git a/src/libply/tests/ply-progress-test.am b/src/libply/tests/ply-progress-test.am deleted file mode 100644 index 6279facf..00000000 --- a/src/libply/tests/ply-progress-test.am +++ /dev/null @@ -1,15 +0,0 @@ -TESTS += ply-progress-test - -ply_progress_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_PROGRESS_ENABLE_TEST \ - -DPLYMOUTH_TIME_DIRECTORY=\"$(localstatedir)/lib/plymouth/\" -ply_progress_test_LDADD = $(PLYMOUTH_LIBS) - -ply_progress_test_SOURCES = \ - $(srcdir)/../ply-progress.h \ - $(srcdir)/../ply-progress.c \ - $(srcdir)/../ply-list.h \ - $(srcdir)/../ply-list.c \ - $(srcdir)/../ply-logger.h \ - $(srcdir)/../ply-logger.c \ - $(srcdir)/../ply-utils.h \ - $(srcdir)/../ply-utils.c diff --git a/src/libply/tests/ply-region.am b/src/libply/tests/ply-region.am deleted file mode 100644 index 18838336..00000000 --- a/src/libply/tests/ply-region.am +++ /dev/null @@ -1,12 +0,0 @@ -TESTS += ply-region-test - -ply_region_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_REGION_ENABLE_TEST -ply_region_test_LDADD = $(PLYMOUTH_LIBS) - -ply_region_test_SOURCES = \ - $(srcdir)/../ply-region.h \ - $(srcdir)/../ply-region.c \ - $(srcdir)/../ply-rectangle.h \ - $(srcdir)/../ply-rectangle.c \ - $(srcdir)/../ply-list.h \ - $(srcdir)/../ply-list.c diff --git a/src/libply/tests/ply-terminal-session-test.am b/src/libply/tests/ply-terminal-session-test.am deleted file mode 100644 index decb531b..00000000 --- a/src/libply/tests/ply-terminal-session-test.am +++ /dev/null @@ -1,18 +0,0 @@ -TESTS += ply-terminal-session-test - -ply_terminal_session_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_TERMINAL_SESSION_ENABLE_TEST -ply_terminal_session_test_LDADD = $(PLYMOUTH_LIBS) - -ply_terminal_session_test_SOURCES = \ - $(srcdir)/../ply-utils.h \ - $(srcdir)/../ply-utils.c \ - $(srcdir)/../ply-buffer.h \ - $(srcdir)/../ply-buffer.c \ - $(srcdir)/../ply-logger.h \ - $(srcdir)/../ply-logger.c \ - $(srcdir)/../ply-list.h \ - $(srcdir)/../ply-list.c \ - $(srcdir)/../ply-event-loop.h \ - $(srcdir)/../ply-event-loop.c \ - $(srcdir)/../ply-terminal-session.h \ - $(srcdir)/../ply-terminal-session.c @@ -43,10 +43,12 @@ #include "ply-command-parser.h" #include "ply-boot-server.h" #include "ply-boot-splash.h" +#include "ply-device-manager.h" #include "ply-event-loop.h" #include "ply-hashtable.h" #include "ply-list.h" #include "ply-logger.h" +#include "ply-renderer.h" #include "ply-terminal-session.h" #include "ply-trigger.h" #include "ply-utils.h" @@ -84,9 +86,6 @@ typedef struct { ply_event_loop_t *loop; ply_boot_server_t *boot_server; - ply_list_t *pixel_displays; - ply_list_t *text_displays; - ply_keyboard_t *keyboard; ply_boot_splash_t *boot_splash; ply_terminal_session_t *session; ply_buffer_t *boot_buffer; @@ -97,8 +96,8 @@ typedef struct ply_list_t *messages; ply_command_parser_t *command_parser; ply_mode_t mode; - ply_renderer_t *renderer; ply_terminal_t *local_console_terminal; + ply_device_manager_t *device_manager; ply_trigger_t *deactivate_trigger; ply_trigger_t *quit_trigger; @@ -116,7 +115,6 @@ typedef struct uint32_t is_shown : 1; uint32_t should_force_details : 1; - char *kernel_console_tty; char *override_splash_path; char *system_default_splash_path; char *distribution_default_splash_path; @@ -125,15 +123,14 @@ typedef struct int number_of_errors; } state_t; -static ply_boot_splash_t *start_boot_splash (state_t *state, - const char *theme_path, - bool fall_back_if_neccessary); - -static void add_display_and_keyboard_for_terminal (state_t *state, - ply_terminal_t *terminal); - -static void add_default_displays_and_keyboard (state_t *state); +static void load_splash (state_t *state); +static ply_boot_splash_t *load_built_in_theme (state_t *state); +static ply_boot_splash_t *load_theme (state_t *state, + const char *theme_path); +static void show_theme (state_t *state, + ply_boot_splash_t *splash); +static void attach_splash_to_seats (state_t *state); static bool attach_to_running_session (state_t *state); static void detach_from_running_session (state_t *state); static void on_escape_pressed (state_t *state); @@ -146,15 +143,19 @@ static void on_error_message (ply_buffer_t *debug_buffer, static ply_buffer_t *debug_buffer; static char *debug_buffer_path = NULL; static char *pid_file = NULL; -static void check_for_consoles (state_t *state, - const char *default_tty, - bool should_add_displays); static void toggle_between_splash_and_details (state_t *state); #ifdef PLY_ENABLE_SYSTEMD_INTEGRATION static void tell_systemd_to_print_details (state_t *state); static void tell_systemd_to_stop_printing_details (state_t *state); #endif static const char * get_cache_file_for_mode (ply_mode_t mode); +static void on_escape_pressed (state_t *state); +static void on_enter (state_t *state, + const char *line); +static void on_keyboard_input (state_t *state, + const char *keyboard_input, + size_t character_size); +static void on_backspace (state_t *state); static void on_session_output (state_t *state, @@ -254,20 +255,23 @@ show_messages (state_t *state) } static void -show_detailed_splash (state_t *state) +load_detailed_splash (state_t *state) { + ply_boot_splash_t *splash; + if (state->boot_splash != NULL) return; ply_trace ("Showing detailed splash screen"); - state->boot_splash = start_boot_splash (state, - PLYMOUTH_THEME_PATH "details/details.plymouth", - true); + splash = load_built_in_theme (state); - if (state->boot_splash == NULL) + if (splash == NULL) { ply_trace ("Could not start detailed splash screen, this could be a problem."); + return; } + + state->boot_splash = splash; } static const char * @@ -392,7 +396,7 @@ find_distribution_default_splash (state_t *state) } static void -show_default_splash (state_t *state) +load_default_splash (state_t *state) { if (state->boot_splash != NULL) return; @@ -402,9 +406,7 @@ show_default_splash (state_t *state) if (state->override_splash_path != NULL) { ply_trace ("Trying override splash at '%s'", state->override_splash_path); - state->boot_splash = start_boot_splash (state, - state->override_splash_path, - false); + state->boot_splash = load_theme (state, state->override_splash_path); } find_system_default_splash (state); @@ -412,9 +414,7 @@ show_default_splash (state_t *state) state->system_default_splash_path != NULL) { ply_trace ("Trying system default splash"); - state->boot_splash = start_boot_splash (state, - state->system_default_splash_path, - false); + state->boot_splash = load_theme (state, state->system_default_splash_path); } find_distribution_default_splash (state); @@ -422,39 +422,34 @@ show_default_splash (state_t *state) state->distribution_default_splash_path != NULL) { ply_trace ("Trying distribution default splash"); - state->boot_splash = start_boot_splash (state, - state->distribution_default_splash_path, - false); + state->boot_splash = load_theme (state, state->distribution_default_splash_path); } if (state->boot_splash == NULL) { ply_trace ("Trying old scheme for default splash"); - state->boot_splash = start_boot_splash (state, - PLYMOUTH_THEME_PATH "default.plymouth", - false); + state->boot_splash = load_theme (state, PLYMOUTH_THEME_PATH "default.plymouth"); } if (state->boot_splash == NULL) { ply_trace ("Could not start default splash screen," "showing text splash screen"); - state->boot_splash = start_boot_splash (state, - PLYMOUTH_THEME_PATH "text/text.plymouth", - false); + state->boot_splash = load_theme (state, PLYMOUTH_THEME_PATH "text/text.plymouth"); } if (state->boot_splash == NULL) { ply_trace ("Could not start text splash screen," - "showing built-in fallback"); - state->boot_splash = start_boot_splash (state, - PLYMOUTH_THEME_PATH "text/text.plymouth", - true); + "showing built-in splash screen"); + state->boot_splash = load_built_in_theme (state); } if (state->boot_splash == NULL) - ply_error ("plymouthd: could not start boot splash: %m"); + { + ply_error ("plymouthd: could not start boot splash: %m"); + return; + } } static void @@ -820,55 +815,9 @@ plymouth_should_show_default_splash (state_t *state) } static void -remove_displays_and_keyboard (state_t *state) -{ - ply_list_node_t *node; - ply_trace ("removing displays and keyboard"); - - node = ply_list_get_first_node (state->pixel_displays); - while (node != NULL) - { - ply_list_node_t *next_node; - ply_pixel_display_t *display; - - ply_trace ("removing pixel display"); - next_node = ply_list_get_next_node (state->pixel_displays, node); - display = ply_list_node_get_data (node); - ply_pixel_display_free (display); - - ply_list_remove_node (state->pixel_displays, node); - - node = next_node; - } - - node = ply_list_get_first_node (state->text_displays); - while (node != NULL) - { - ply_list_node_t *next_node; - ply_text_display_t *display; - - ply_trace ("removing text display"); - next_node = ply_list_get_next_node (state->text_displays, node); - display = ply_list_node_get_data (node); - ply_text_display_free (display); - - ply_list_remove_node (state->text_displays, node); - - node = next_node; - } - - if (state->keyboard != NULL) - { - ply_trace ("removing keyboard"); - ply_keyboard_free (state->keyboard); - state->keyboard = NULL; - } -} - -static void on_show_splash (state_t *state) { - bool has_display; + bool has_open_seats; if (state->is_shown) { @@ -890,90 +839,127 @@ on_show_splash (state_t *state) } state->is_shown = true; + has_open_seats = ply_device_manager_has_open_seats (state->device_manager); - check_for_consoles (state, state->default_tty, true); - - has_display = ply_list_get_length (state->pixel_displays) > 0 || - ply_list_get_length (state->text_displays) > 0; - - if (!state->is_attached && state->should_be_attached && has_display) + if (!state->is_attached && state->should_be_attached && has_open_seats) attach_to_running_session (state); - if (!has_display) + if (has_open_seats) + { + ply_trace ("at least one seat already open, so loading splash"); + load_splash (state); + show_theme (state, state->boot_splash); + } + else { - ply_trace ("no open seats"); - detach_from_running_session (state); + ply_trace ("no seats available to show splash on, waiting..."); } +} + +static void +on_seat_removed (state_t *state, + ply_seat_t *seat) +{ + ply_keyboard_t *keyboard; + + keyboard = ply_seat_get_keyboard (seat); + + ply_trace ("no longer listening for keystrokes"); + ply_keyboard_remove_input_handler (keyboard, + (ply_keyboard_input_handler_t) + on_keyboard_input); + ply_trace ("no longer listening for escape"); + ply_keyboard_remove_escape_handler (keyboard, + (ply_keyboard_escape_handler_t) + on_escape_pressed); + ply_trace ("no longer listening for backspace"); + ply_keyboard_remove_backspace_handler (keyboard, + (ply_keyboard_backspace_handler_t) + on_backspace); + ply_trace ("no longer listening for enter"); + ply_keyboard_remove_enter_handler (keyboard, + (ply_keyboard_enter_handler_t) + on_enter); + + if (state->boot_splash != NULL) + ply_boot_splash_detach_from_seat (state->boot_splash, seat); +} + +static void +load_splash (state_t *state) +{ + if (state->boot_splash != NULL) + return; if (plymouth_should_show_default_splash (state)) { - show_default_splash (state); + load_default_splash (state); state->showing_details = false; } else { - show_detailed_splash (state); + load_detailed_splash (state); state->showing_details = true; } - show_messages (state); } -static ply_list_t * -get_tracked_terminals (state_t *state) +static void +on_seat_added (state_t *state, + ply_seat_t *seat) { - ply_list_t *terminals; - ply_list_node_t *node; - - terminals = ply_list_new (); + ply_keyboard_t *keyboard; - node = ply_list_get_first_node (state->text_displays); - while (node != NULL) + if (state->boot_splash == NULL) { - ply_list_node_t *next_node; - ply_text_display_t *display; - ply_terminal_t *terminal; + ply_trace ("seat added before splash loaded, so loading splash now"); + load_splash (state); + } - next_node = ply_list_get_next_node (state->text_displays, node); - display = ply_list_node_get_data (node); - terminal = ply_text_display_get_terminal (display); + if (state->boot_splash != NULL && state->is_shown) + { + ply_trace ("show-splash already requested, so showing splash now"); + show_theme (state, state->boot_splash); + } - ply_list_append_data (terminals, terminal); + keyboard = ply_seat_get_keyboard (seat); - node = next_node; - } + ply_trace ("listening for keystrokes"); + ply_keyboard_add_input_handler (keyboard, + (ply_keyboard_input_handler_t) + on_keyboard_input, state); + ply_trace ("listening for escape"); + ply_keyboard_add_escape_handler (keyboard, + (ply_keyboard_escape_handler_t) + on_escape_pressed, state); + ply_trace ("listening for backspace"); + ply_keyboard_add_backspace_handler (keyboard, + (ply_keyboard_backspace_handler_t) + on_backspace, state); + ply_trace ("listening for enter"); + ply_keyboard_add_enter_handler (keyboard, + (ply_keyboard_enter_handler_t) + on_enter, state); - return terminals; } static void -free_terminals (state_t *state, - ply_list_t *terminals) +load_devices (state_t *state, + ply_device_manager_flags_t flags) { - ply_list_node_t *node; - node = ply_list_get_first_node (terminals); - while (node != NULL) - { - ply_list_node_t *next_node; - ply_terminal_t *terminal; + state->device_manager = ply_device_manager_new (state->default_tty, flags); + state->local_console_terminal = ply_device_manager_get_default_terminal (state->device_manager); - next_node = ply_list_get_next_node (state->text_displays, node); - terminal = ply_list_node_get_data (node); - - ply_terminal_close (terminal); - ply_terminal_free (terminal); - ply_list_remove_node (terminals, node); - - node = next_node; - } - - ply_list_free (terminals); + ply_device_manager_watch_seats (state->device_manager, + (ply_seat_added_handler_t) + on_seat_added, + (ply_seat_removed_handler_t) + on_seat_removed, + state); } static void quit_splash (state_t *state) { - ply_list_t *terminals; - ply_trace ("quiting splash"); if (state->boot_splash != NULL) { @@ -982,18 +968,6 @@ quit_splash (state_t *state) state->boot_splash = NULL; } - terminals = get_tracked_terminals (state); - - ply_trace ("removing displays and keyboard"); - remove_displays_and_keyboard (state); - - if (state->renderer != NULL) - { - ply_renderer_close (state->renderer); - ply_renderer_free (state->renderer); - state->renderer = NULL; - } - if (state->local_console_terminal != NULL) { if (!state->should_retain_splash) @@ -1003,21 +977,30 @@ quit_splash (state_t *state) } state->local_console_terminal = NULL; } - free_terminals (state, terminals); detach_from_running_session (state); } static void +hide_splash (state_t *state) +{ + if (state->boot_splash == NULL) + return; + + ply_boot_splash_hide (state->boot_splash); + + if (state->local_console_terminal != NULL) + ply_terminal_set_mode (state->local_console_terminal, PLY_TERMINAL_MODE_TEXT); +} + +static void dump_details_and_quit_splash (state_t *state) { state->showing_details = false; toggle_between_splash_and_details (state); - if (state->renderer != NULL) - ply_renderer_deactivate (state->renderer); - if (state->boot_splash != NULL) - ply_boot_splash_hide (state->boot_splash); + ply_device_manager_deactivate_renderers (state->device_manager); + hide_splash (state); state->is_shown = false; @@ -1051,6 +1034,9 @@ tell_gdm_to_transition (void) static void quit_program (state_t *state) { + ply_trace ("cleaning up devices"); + ply_device_manager_free (state->device_manager); + ply_trace ("exiting event loop"); ply_event_loop_exit (state->loop, 0); @@ -1086,11 +1072,7 @@ deactivate_splash (state_t *state) { assert (!state->is_inactive); - if (state->renderer != NULL) - { - ply_trace ("deactivating renderer"); - ply_renderer_deactivate (state->renderer); - } + ply_device_manager_deactivate_renderers (state->device_manager); detach_from_running_session (state); @@ -1128,10 +1110,8 @@ on_boot_splash_idle (state_t *state) if (!state->should_retain_splash) { ply_trace ("hiding splash"); - if (state->renderer != NULL) - ply_renderer_deactivate (state->renderer); - if (state->boot_splash != NULL) - ply_boot_splash_hide (state->boot_splash); + ply_device_manager_deactivate_renderers (state->device_manager); + hide_splash (state); state->is_shown = false; } @@ -1148,7 +1128,6 @@ on_boot_splash_idle (state_t *state) } } - static void on_deactivate (state_t *state, ply_trigger_t *deactivate_trigger) @@ -1171,12 +1150,7 @@ on_deactivate (state_t *state, state->deactivate_trigger = deactivate_trigger; ply_trace ("deactivating"); - - if (state->keyboard != NULL) - { - ply_trace ("deactivating keyboard"); - ply_keyboard_stop_watching_for_input (state->keyboard); - } + ply_device_manager_deactivate_keyboards (state->device_manager); if (state->boot_splash != NULL) { @@ -1212,17 +1186,8 @@ on_reactivate (state_t *state) attach_to_running_session (state); } - if (state->keyboard != NULL) - { - ply_trace ("activating keyboard"); - ply_keyboard_watch_for_input (state->keyboard); - } - - if (state->renderer != NULL) - { - ply_trace ("activating renderer"); - ply_renderer_activate (state->renderer); - } + ply_device_manager_activate_keyboards (state->device_manager); + ply_device_manager_activate_renderers (state->device_manager); state->is_inactive = false; @@ -1258,11 +1223,7 @@ on_quit (state_t *state, if (state->session != NULL) ply_terminal_session_close_log (state->session); - if (state->keyboard != NULL) - { - ply_trace ("deactivating keyboard"); - ply_keyboard_stop_watching_for_input (state->keyboard); - } + ply_device_manager_deactivate_keyboards (state->device_manager); ply_trace ("unloading splash"); if (state->is_inactive && !retain_splash) @@ -1376,23 +1337,22 @@ toggle_between_splash_and_details (state_t *state) if (state->boot_splash != NULL) { ply_trace ("hiding and freeing current splash"); - ply_boot_splash_hide (state->boot_splash); + hide_splash (state); ply_boot_splash_free (state->boot_splash); state->boot_splash = NULL; } if (!state->showing_details) { - show_detailed_splash (state); + load_detailed_splash (state); state->showing_details = true; } else { - show_default_splash (state); + load_default_splash (state); state->showing_details = false; } - update_display (state); - show_messages (state); + show_theme (state, state->boot_splash); } static void @@ -1504,140 +1464,23 @@ on_enter (state_t *state, } static void -set_keyboard (state_t *state, - ply_keyboard_t *keyboard) -{ - state->keyboard = keyboard; - - ply_keyboard_add_escape_handler (keyboard, (ply_keyboard_escape_handler_t) - on_escape_pressed, state); - ply_trace ("listening for keystrokes"); - ply_keyboard_add_input_handler (keyboard, - (ply_keyboard_input_handler_t) - on_keyboard_input, state); - ply_trace ("listening for backspace"); - ply_keyboard_add_backspace_handler (keyboard, - (ply_keyboard_backspace_handler_t) - on_backspace, state); - ply_trace ("listening for enter"); - ply_keyboard_add_enter_handler (keyboard, - (ply_keyboard_enter_handler_t) - on_enter, state); -} -static void -add_display_and_keyboard_for_terminal (state_t *state, - ply_terminal_t *terminal) -{ - ply_text_display_t *display; - ply_keyboard_t *keyboard; - - keyboard = ply_keyboard_new_for_terminal (terminal); - display = ply_text_display_new (terminal); - - ply_list_append_data (state->text_displays, display); - set_keyboard (state, keyboard); -} - -static void -add_pixel_displays_from_renderer (state_t *state, - ply_renderer_t *renderer) -{ - ply_list_t *heads; - ply_list_node_t *node; - - heads = ply_renderer_get_heads (renderer); - - ply_trace ("Adding displays for %d heads", - ply_list_get_length (heads)); - - node = ply_list_get_first_node (heads); - while (node != NULL) - { - ply_list_node_t *next_node; - ply_renderer_head_t *head; - ply_pixel_display_t *display; - - head = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (heads, node); - - display = ply_pixel_display_new (renderer, head); - - ply_list_append_data (state->pixel_displays, display); - - node = next_node; - } - -} - -static void -add_default_displays_and_keyboard (state_t *state) +attach_splash_to_seats (state_t *state) { - ply_renderer_t *renderer; - ply_keyboard_t *keyboard; - ply_text_display_t *text_display; - - ply_trace ("adding default displays and keyboard"); - state->local_console_terminal = ply_terminal_new (state->default_tty); - - renderer = ply_renderer_new (NULL, NULL, state->local_console_terminal); - - if (!ply_renderer_open (renderer)) - { - ply_trace ("could not open renderer /dev/fb"); - ply_renderer_free (renderer); - - ply_trace ("adding text display and keyboard for %s", state->default_tty); - add_display_and_keyboard_for_terminal (state, state->local_console_terminal); - return; - } - - keyboard = ply_keyboard_new_for_renderer (renderer); - set_keyboard (state, keyboard); - - add_pixel_displays_from_renderer (state, renderer); - - text_display = ply_text_display_new (state->local_console_terminal); - ply_list_append_data (state->text_displays, text_display); - - state->renderer = renderer; -} - -static void -add_displays_and_keyboard_to_boot_splash (state_t *state, - ply_boot_splash_t *splash) -{ + ply_list_t *seats; ply_list_node_t *node; - ply_trace ("setting keyboard on boot splash"); - if (state->keyboard != NULL) - ply_boot_splash_set_keyboard (splash, state->keyboard); - - node = ply_list_get_first_node (state->pixel_displays); - while (node != NULL) - { - ply_pixel_display_t *display; - ply_list_node_t *next_node; - - display = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (state->pixel_displays, node); - ply_trace ("adding pixel display on boot splash"); - ply_boot_splash_add_pixel_display (splash, display); - - node = next_node; - } - - node = ply_list_get_first_node (state->text_displays); + seats = ply_device_manager_get_seats (state->device_manager); + node = ply_list_get_first_node (seats); while (node != NULL) { - ply_text_display_t *display; + ply_seat_t *seat; ply_list_node_t *next_node; - display = ply_list_node_get_data (node); - next_node = ply_list_get_next_node (state->text_displays, node); + seat = ply_list_node_get_data (node); + next_node = ply_list_get_next_node (seats, node); - ply_trace ("adding text display on boot splash"); - ply_boot_splash_add_text_display (splash, display); + ply_boot_splash_attach_to_seat (state->boot_splash, seat); node = next_node; } @@ -1662,12 +1505,41 @@ tell_systemd_to_stop_printing_details (state_t *state) #endif static ply_boot_splash_t * -start_boot_splash (state_t *state, - const char *theme_path, - bool fall_back_if_neccessary) +load_built_in_theme (state_t *state) +{ + ply_boot_splash_t *splash; + bool is_loaded; + + ply_trace ("Loading built-in theme"); + + splash = ply_boot_splash_new ("", + PLYMOUTH_PLUGIN_PATH, + state->boot_buffer); + + is_loaded = ply_boot_splash_load_built_in (splash); + + if (!is_loaded) + { + ply_save_errno (); + ply_boot_splash_free (splash); + ply_restore_errno (); + return NULL; + } + + ply_trace ("attaching plugin to event loop"); + ply_boot_splash_attach_to_event_loop (splash, state->loop); + + ply_trace ("attaching progress to plugin"); + ply_boot_splash_attach_progress (splash, state->progress); + + return splash; +} + +static ply_boot_splash_t * +load_theme (state_t *state, + const char *theme_path) { ply_boot_splash_t *splash; - ply_boot_splash_mode_t splash_mode; bool is_loaded; ply_trace ("Loading boot splash theme '%s'", @@ -1678,13 +1550,6 @@ start_boot_splash (state_t *state, state->boot_buffer); is_loaded = ply_boot_splash_load (splash); - if (!is_loaded && fall_back_if_neccessary) - { - ply_trace ("Splash couldn't be loaded: %m"); - - ply_trace ("Loading built in splash"); - is_loaded = ply_boot_splash_load_built_in (splash); - } if (!is_loaded) { @@ -1700,7 +1565,17 @@ start_boot_splash (state_t *state, ply_trace ("attaching progress to plugin"); ply_boot_splash_attach_progress (splash, state->progress); - add_displays_and_keyboard_to_boot_splash (state, splash); + return splash; +} + +static void +show_theme (state_t *state, + ply_boot_splash_t *splash) +{ + ply_boot_splash_mode_t splash_mode; + + attach_splash_to_seats (state); + ply_device_manager_activate_renderers (state->device_manager); ply_trace ("showing plugin"); if (state->mode == PLY_MODE_SHUTDOWN) @@ -1711,10 +1586,9 @@ start_boot_splash (state_t *state, if (!ply_boot_splash_show (splash, splash_mode)) { ply_save_errno (); - ply_boot_splash_unset_keyboard (splash); ply_boot_splash_free (splash); ply_restore_errno (); - return NULL; + return; } #ifdef PLY_ENABLE_SYSTEMD_INTEGRATION @@ -1722,11 +1596,9 @@ start_boot_splash (state_t *state, tell_systemd_to_print_details (state); #endif - if (state->keyboard != NULL) - ply_keyboard_watch_for_input (state->keyboard); - + ply_device_manager_activate_keyboards (state->device_manager); + show_messages (state); update_display (state); - return splash; } static bool @@ -1904,10 +1776,7 @@ check_verbosity (state_t *state) const char* device; char *file; - if (state->kernel_console_tty != NULL) - device = state->kernel_console_tty; - else - device = state->default_tty; + device = state->default_tty; ply_trace ("redirecting debug output to %s", device); @@ -1962,237 +1831,6 @@ check_logging (state_t *state) } } -static void -add_display_and_keyboard_for_console (const char *console, - const char *null, - state_t *state) -{ - ply_terminal_t *terminal; - - terminal = ply_terminal_new (console); - - if (strcmp (console, state->default_tty) == 0) - state->local_console_terminal = terminal; - - ply_trace ("adding display and keyboard for console %s", console); - add_display_and_keyboard_for_terminal (state, terminal); -} - -static int -add_consoles_from_file (state_t *state, - ply_hashtable_t *consoles, - const char *path) -{ - int fd; - char contents[512] = ""; - ssize_t contents_length; - int num_consoles; - const char *remaining_file_contents; - - ply_trace ("opening %s", path); - fd = open (path, O_RDONLY); - - if (fd < 0) - { - ply_trace ("couldn't open it: %m"); - return 0; - } - - ply_trace ("reading file"); - contents_length = read (fd, contents, sizeof (contents) - 1); - - if (contents_length <= 0) - { - ply_trace ("couldn't read it: %m"); - close (fd); - return 0; - } - close (fd); - - remaining_file_contents = contents; - num_consoles = 0; - - while (remaining_file_contents < contents + contents_length) - { - char *console; - size_t console_length; - char *console_device; - - /* Advance past any leading whitespace */ - remaining_file_contents += strspn (remaining_file_contents, " \n\t\v"); - - if (*remaining_file_contents == '\0') - { - /* There's nothing left after the whitespace, we're done */ - break; - } - - /* Find trailing whitespace and NUL terminate. If strcspn - * doesn't find whitespace, it gives us the length of the string - * until the next NUL byte, which we'll just overwrite with - * another NUL byte anyway. */ - console_length = strcspn (remaining_file_contents, " \n\t\v"); - console = strndup (remaining_file_contents, console_length); - - /* If this console is anything besides tty0, then the user is sort - * of a weird case (uses a serial console or whatever) and they - * most likely don't want a graphical splash, so force details. - */ - if (strcmp (console, "tty0") != 0) - state->should_force_details = true; - - asprintf (&console_device, "/dev/%s", console); - - free (console); - - ply_trace ("console %s found!", console_device); - ply_hashtable_insert (consoles, console_device, console_device); - num_consoles++; - - /* Move past the parsed console string, and the whitespace we - * may have found above. If we found a NUL above and not whitespace, - * then we're going to jump past the end of the buffer and the loop - * will terminate - */ - remaining_file_contents += console_length + 1; - } - - return num_consoles; -} - -static int -add_consoles_from_kernel_command_line (state_t *state, - ply_hashtable_t *consoles) -{ - const char *console_string; - const char *remaining_command_line; - char *console; - int num_consoles; - - remaining_command_line = state->kernel_command_line; - - num_consoles = 0; - console = NULL; - while ((console_string = command_line_get_string_after_prefix (remaining_command_line, - "console=")) != NULL) - { - char *end; - size_t console_length; - char *console_device; - - remaining_command_line = console_string; - - state->should_force_details = true; - - console = strdup (console_string); - - end = strpbrk (console, " \n\t\v,"); - - if (end != NULL) - *end = '\0'; - - console_length = strlen (console); - - if (strncmp (console, "/dev/", strlen ("/dev/")) == 0) - { - console_device = console; - console = NULL; - } - else - { - asprintf (&console_device, "/dev/%s", console); - free (console); - console = NULL; - } - - ply_trace ("console %s found!", console_device); - ply_hashtable_insert (consoles, console_device, console_device); - num_consoles++; - remaining_command_line += console_length; - } - - return num_consoles; -} - -static void -check_for_consoles (state_t *state, - const char *default_tty, - bool should_add_displays) -{ - char *console; - ply_hashtable_t *consoles; - int num_consoles; - bool ignore_serial_consoles; - - ply_trace ("checking for consoles%s", - should_add_displays? " and adding displays": ""); - - consoles = ply_hashtable_new (ply_hashtable_string_hash, - ply_hashtable_string_compare); - ignore_serial_consoles = command_line_has_argument (state->kernel_command_line, "plymouth.ignore-serial-consoles"); - - num_consoles = 0; - - if (!ignore_serial_consoles) - { - num_consoles = add_consoles_from_file (state, consoles, "/sys/class/tty/console/active"); - - if (num_consoles == 0) - { - ply_trace ("falling back to kernel command line"); - num_consoles = add_consoles_from_kernel_command_line (state, consoles); - } - } - else - { - ply_trace ("ignoring all consoles but default console because of plymouth.ignore-serial-consoles"); - } - - console = ply_hashtable_remove (consoles, (void *) "/dev/tty0"); - if (console != NULL) - { - free (console); - console = strdup (default_tty); - ply_hashtable_insert (consoles, console, console); - } - - console = ply_hashtable_remove (consoles, (void *) "/dev/tty"); - if (console != NULL) - { - free (console); - console = strdup (default_tty); - ply_hashtable_insert (consoles, console, console); - } - - free (state->kernel_console_tty); - state->kernel_console_tty = NULL; - - if (console != NULL) - state->kernel_console_tty = strdup (console); - - if (should_add_displays) - { - /* Do a full graphical splash if there's no weird serial console - * stuff going on, otherwise just prepare text splashes - */ - if ((num_consoles == 0) || - ((num_consoles == 1) && - (ply_hashtable_lookup (consoles, (void *) default_tty) != NULL))) - add_default_displays_and_keyboard (state); - else - ply_hashtable_foreach (consoles, - (ply_hashtable_foreach_func_t *) - add_display_and_keyboard_for_console, - state); - } - - ply_hashtable_foreach (consoles, (ply_hashtable_foreach_func_t *) free, NULL); - ply_hashtable_free (consoles); - - ply_trace ("After processing serial consoles there are now %d text displays", - ply_list_get_length (state->text_displays)); -} - static bool redirect_standard_io_to_dev_null (void) { @@ -2274,13 +1912,7 @@ initialize_environment (state_t *state) state->keystroke_triggers = ply_list_new (); state->entry_triggers = ply_list_new (); state->entry_buffer = ply_buffer_new(); - state->pixel_displays = ply_list_new (); - state->text_displays = ply_list_new (); state->messages = ply_list_new (); - state->keyboard = NULL; - - - check_for_consoles (state, state->default_tty, false); redirect_standard_io_to_dev_null (); @@ -2390,6 +2022,7 @@ main (int argc, char *mode_string = NULL; char *kernel_command_line = NULL; char *tty = NULL; + ply_device_manager_flags_t device_manager_flags = PLY_DEVICE_MANAGER_FLAGS_NONE; state.command_parser = ply_command_parser_new ("plymouthd", "Splash server"); @@ -2564,6 +2197,15 @@ main (int argc, return EX_UNAVAILABLE; } + if (command_line_has_argument (state.kernel_command_line, "plymouth.ignore-serial-consoles")) + device_manager_flags |= PLY_DEVICE_MANAGER_FLAGS_IGNORE_SERIAL_CONSOLES; + + if (command_line_has_argument (state.kernel_command_line, "plymouth.ignore-udev") || + (getenv ("DISPLAY") != NULL)) + device_manager_flags |= PLY_DEVICE_MANAGER_FLAGS_IGNORE_UDEV; + + load_devices (&state, device_manager_flags); + ply_trace ("entering event loop"); exit_code = ply_event_loop_run (state.loop); ply_trace ("exited event loop"); diff --git a/src/plugins/renderers/drm/plugin.c b/src/plugins/renderers/drm/plugin.c index 945f15e6..6677279d 100644 --- a/src/plugins/renderers/drm/plugin.c +++ b/src/plugins/renderers/drm/plugin.c @@ -522,6 +522,9 @@ open_device (ply_renderer_backend_t *backend) if (!load_driver (backend)) return false; + if (backend->terminal == NULL) + return true; + if (!ply_terminal_open (backend->terminal)) { ply_trace ("could not open terminal: %m"); @@ -550,10 +553,11 @@ close_device (ply_renderer_backend_t *backend) free_heads (backend); - ply_terminal_stop_watching_for_active_vt_change (backend->terminal, - (ply_terminal_active_vt_changed_handler_t) - on_active_vt_changed, - backend); + if (backend->terminal != NULL) + ply_terminal_stop_watching_for_active_vt_change (backend->terminal, + (ply_terminal_active_vt_changed_handler_t) + on_active_vt_changed, + backend); unload_driver (backend); } @@ -888,10 +892,17 @@ map_to_device (ply_renderer_backend_t *backend) node = next_node; } - if (ply_terminal_is_active (backend->terminal)) - activate (backend); + if (backend->terminal != NULL) + { + if (ply_terminal_is_active (backend->terminal)) + activate (backend); + else + ply_terminal_activate_vt (backend->terminal); + } else - ply_terminal_activate_vt (backend->terminal); + { + activate (backend); + } return head_mapped; } @@ -1019,8 +1030,11 @@ reset_scan_out_buffer_if_needed (ply_renderer_backend_t *backend, drmModeCrtc *controller; bool did_reset = false; - if (!ply_terminal_is_active (backend->terminal)) - return false; + if (backend->terminal != NULL) + { + if (!ply_terminal_is_active (backend->terminal)) + return false; + } controller = drmModeGetCrtc (backend->device_fd, head->controller_id); @@ -1054,8 +1068,11 @@ flush_head (ply_renderer_backend_t *backend, if (!backend->is_active) return; - ply_terminal_set_mode (backend->terminal, PLY_TERMINAL_MODE_GRAPHICS); - ply_terminal_set_unbuffered_input (backend->terminal); + if (backend->terminal != NULL) + { + ply_terminal_set_mode (backend->terminal, PLY_TERMINAL_MODE_GRAPHICS); + ply_terminal_set_unbuffered_input (backend->terminal); + } pixel_buffer = head->pixel_buffer; updated_region = ply_pixel_buffer_get_updated_areas (pixel_buffer); areas_to_flush = ply_region_get_sorted_rectangle_list (updated_region); @@ -1163,6 +1180,9 @@ open_input_source (ply_renderer_backend_t *backend, assert (backend != NULL); assert (has_input_source (backend, input_source)); + if (backend->terminal == NULL) + return false; + terminal_fd = ply_terminal_get_fd (backend->terminal); input_source->backend = backend; @@ -1193,6 +1213,9 @@ close_input_source (ply_renderer_backend_t *backend, assert (backend != NULL); assert (has_input_source (backend, input_source)); + if (backend->terminal == NULL) + return; + ply_event_loop_stop_watching_fd (backend->loop, input_source->terminal_input_watch); input_source->terminal_input_watch = NULL; input_source->backend = NULL; diff --git a/src/plugins/renderers/frame-buffer/plugin.c b/src/plugins/renderers/frame-buffer/plugin.c index 0e079431..dd73a0f7 100644 --- a/src/plugins/renderers/frame-buffer/plugin.c +++ b/src/plugins/renderers/frame-buffer/plugin.c @@ -351,6 +351,9 @@ open_device (ply_renderer_backend_t *backend) return false; } + if (backend->terminal == NULL) + return true; + if (!ply_terminal_open (backend->terminal)) { ply_trace ("could not open terminal: %m"); @@ -376,10 +379,11 @@ static void close_device (ply_renderer_backend_t *backend) { - ply_terminal_stop_watching_for_active_vt_change (backend->terminal, - (ply_terminal_active_vt_changed_handler_t) - on_active_vt_changed, - backend); + if (backend->terminal != NULL) + ply_terminal_stop_watching_for_active_vt_change (backend->terminal, + (ply_terminal_active_vt_changed_handler_t) + on_active_vt_changed, + backend); uninitialize_head (backend, &backend->head); close (backend->device_fd); @@ -546,15 +550,22 @@ map_to_device (ply_renderer_backend_t *backend) return false; } - if (ply_terminal_is_active (backend->terminal)) + if (backend->terminal != NULL) { - ply_trace ("already on right vt, activating"); - activate (backend); + if (ply_terminal_is_active (backend->terminal)) + { + ply_trace ("already on right vt, activating"); + activate (backend); + } + else + { + ply_trace ("on wrong vt, changing vts"); + ply_terminal_activate_vt (backend->terminal); + } } else { - ply_trace ("on wrong vt, changing vts"); - ply_terminal_activate_vt (backend->terminal); + activate (backend); } return true; @@ -590,8 +601,11 @@ flush_head (ply_renderer_backend_t *backend, if (!backend->is_active) return; - ply_terminal_set_mode (backend->terminal, PLY_TERMINAL_MODE_GRAPHICS); - ply_terminal_set_unbuffered_input (backend->terminal); + if (backend->terminal != NULL) + { + ply_terminal_set_mode (backend->terminal, PLY_TERMINAL_MODE_GRAPHICS); + ply_terminal_set_unbuffered_input (backend->terminal); + } pixel_buffer = head->pixel_buffer; updated_region = ply_pixel_buffer_get_updated_areas (pixel_buffer); areas_to_flush = ply_region_get_sorted_rectangle_list (updated_region); @@ -685,6 +699,9 @@ open_input_source (ply_renderer_backend_t *backend, assert (backend != NULL); assert (has_input_source (backend, input_source)); + if (backend->terminal == NULL) + return false; + terminal_fd = ply_terminal_get_fd (backend->terminal); input_source->backend = backend; @@ -715,6 +732,9 @@ close_input_source (ply_renderer_backend_t *backend, assert (backend != NULL); assert (has_input_source (backend, input_source)); + if (backend->terminal == NULL) + return; + ply_event_loop_stop_watching_fd (backend->loop, input_source->terminal_input_watch); input_source->terminal_input_watch = NULL; input_source->backend = NULL; diff --git a/src/ply-boot-server.c b/src/ply-boot-server.c index 2d2a5b85..3e67bfbf 100644 --- a/src/ply-boot-server.c +++ b/src/ply-boot-server.c @@ -831,183 +831,4 @@ ply_boot_server_attach_to_event_loop (ply_boot_server_t *server, server); } -#ifdef PLY_BOOT_SERVER_ENABLE_TEST - -#include <stdio.h> - -#include "ply-event-loop.h" -#include "ply-boot-server.h" - -static void -on_update (ply_event_loop_t *loop, - const char *status) -{ - printf ("new status is '%s'\n", status); -} - -static void -on_newroot (ply_event_loop_t *loop) -{ - printf ("got newroot request\n"); -} - -static void -on_system_initialized (ply_event_loop_t *loop) -{ - printf ("got sysinit done request\n"); -} - -static void -on_show_splash (ply_event_loop_t *loop) -{ - printf ("got show splash request\n"); -} - -static void -on_hide_splash (ply_event_loop_t *loop) -{ - printf ("got hide splash request\n"); -} - -static void -on_deactivate (ply_event_loop_t *loop) -{ - printf ("got deactivate request\n"); -} - -static void -on_reactivate (ply_event_loop_t *loop) -{ - printf ("got reactivate request\n"); -} - -static void -on_quit (ply_event_loop_t *loop) -{ - printf ("got quit request, quiting...\n"); - ply_event_loop_exit (loop, 0); -} - -static void -on_error (ply_event_loop_t *loop) -{ - printf ("got error starting service\n"); -} - -static char * -on_ask_for_password (ply_event_loop_t *loop) -{ - printf ("got password request, returning 'password'...\n"); - - return strdup ("password"); -} - -static void -on_ask_question (ply_event_loop_t *loop) -{ - printf ("got question request\n"); - return; -} - -static void -on_display_message (ply_event_loop_t *loop) -{ - printf ("got display message request\n"); - return; -} - -static void -on_hide_message (ply_event_loop_t *loop) -{ - printf ("got hide message request\n"); - return; -} - -static void -on_watch_for_keystroke (ply_event_loop_t *loop) -{ - printf ("got keystroke request\n"); - - return; -} - -static void -on_progress_pause (ply_event_loop_t *loop) -{ - printf ("got progress pause request\n"); - - return; -} - -static void -on_progress_unpause (ply_event_loop_t *loop) -{ - printf ("got progress unpause request\n"); - - return; -} - -static void -on_ignore_keystroke (ply_event_loop_t *loop) -{ - printf ("got keystroke ignore request\n"); - - return; -} - -static bool -on_has_active_vt (ply_event_loop_t *loop) -{ - printf ("got has_active vt? request\n"); - return true; -} - -int -main (int argc, - char **argv) -{ - ply_event_loop_t *loop; - ply_boot_server_t *server; - int exit_code; - - exit_code = 0; - - loop = ply_event_loop_new (); - - server = ply_boot_server_new ((ply_boot_server_update_handler_t) on_update, - (ply_boot_server_change_mode_handler_t) on_change_mode, - (ply_boot_server_system_update_handler_t) on_system_update, - (ply_boot_server_ask_for_password_handler_t) on_ask_for_password, - (ply_boot_server_ask_question_handler_t) on_ask_question, - (ply_boot_server_display_message_handler_t) on_display_message, - (ply_boot_server_hide_message_handler_t) on_hide_message, - (ply_boot_server_watch_for_keystroke_handler_t) on_watch_for_keystroke, - (ply_boot_server_ignore_keystroke_handler_t) on_ignore_keystroke, - (ply_boot_server_progress_pause_handler_t) on_progress_pause, - (ply_boot_server_progress_unpause_handler_t) on_progress_unpause, - (ply_boot_server_show_splash_handler_t) on_show_splash, - (ply_boot_server_hide_splash_handler_t) on_hide_splash, - (ply_boot_server_newroot_handler_t) on_newroot, - (ply_boot_server_system_initialized_handler_t) on_system_initialized, - (ply_boot_server_error_handler_t) on_error, - (ply_boot_server_deactivate_handler_t) on_deactivate, - (ply_boot_server_reactivate_handler_t) on_reactivate, - (ply_boot_server_quit_handler_t) on_quit, - (ply_boot_server_has_active_vt_handler_t) on_has_active_vt, - loop); - - if (!ply_boot_server_listen (server)) - { - perror ("could not start boot status daemon"); - return errno; - } - - ply_boot_server_attach_to_event_loop (server, loop); - exit_code = ply_event_loop_run (loop); - ply_boot_server_free (server); - - return exit_code; -} - -#endif /* PLY_BOOT_SERVER_ENABLE_TEST */ /* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */ diff --git a/src/tests/Makefile.am b/src/tests/Makefile.am deleted file mode 100644 index 86a8ea61..00000000 --- a/src/tests/Makefile.am +++ /dev/null @@ -1,18 +0,0 @@ -INCLUDES = \ - -I$(top_srcdir) \ - -I$(srcdir)/.. \ - -I$(srcdir)/../libply \ - -I$(srcdir)/../libply-splash-core \ - -I$(srcdir) -TESTS = - -if ENABLE_TESTS -include $(srcdir)/ply-boot-server-test.am -include $(srcdir)/ply-boot-splash-test.am -endif - -noinst_PROGRAMS = $(TESTS) - -# our tests aren't unit tests, so clear for now -TESTS = -MAINTAINERCLEANFILES = Makefile.in diff --git a/src/tests/ply-boot-server-test.am b/src/tests/ply-boot-server-test.am deleted file mode 100644 index cc283487..00000000 --- a/src/tests/ply-boot-server-test.am +++ /dev/null @@ -1,8 +0,0 @@ -TESTS += ply-boot-server-test - -ply_boot_server_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_BOOT_SERVER_ENABLE_TEST -ply_boot_server_test_LDADD = $(PLYMOUTH_LIBS) ../libply/libply.la - -ply_boot_server_test_SOURCES = \ - $(srcdir)/../ply-boot-server.h \ - $(srcdir)/../ply-boot-server.c diff --git a/src/tests/ply-boot-splash-test.am b/src/tests/ply-boot-splash-test.am deleted file mode 100644 index 9dd15989..00000000 --- a/src/tests/ply-boot-splash-test.am +++ /dev/null @@ -1,25 +0,0 @@ -TESTS += ply-boot-splash-test - -ply_boot_splash_test_CFLAGS = $(PLYMOUTH_CFLAGS) -DPLY_BOOT_SPLASH_ENABLE_TEST \ - -DPLYMOUTH_TIME_DIRECTORY=\"/var/lib/plymouth\" \ - -DPLYMOUTH_PLUGIN_PATH=\"$(PLYMOUTH_PLUGIN_PATH)\" \ - -DPLYMOUTH_THEME_PATH=\"$(PLYMOUTH_THEME_PATH)/\" - -ply_boot_splash_test_LDADD = $(PLYMOUTH_LIBS) ../libply/libply.la - -ply_boot_splash_test_SOURCES = \ - $(srcdir)/../libply-splash-core/ply-boot-splash-plugin.h \ - $(srcdir)/../libply-splash-core/ply-keyboard.h \ - $(srcdir)/../libply-splash-core/ply-keyboard.c \ - $(srcdir)/../libply-splash-core/ply-pixel-buffer.h \ - $(srcdir)/../libply-splash-core/ply-pixel-buffer.c \ - $(srcdir)/../libply-splash-core/ply-pixel-display.h \ - $(srcdir)/../libply-splash-core/ply-pixel-display.c \ - $(srcdir)/../libply-splash-core/ply-renderer.h \ - $(srcdir)/../libply-splash-core/ply-renderer.c \ - $(srcdir)/../libply-splash-core/ply-terminal.h \ - $(srcdir)/../libply-splash-core/ply-terminal.c \ - $(srcdir)/../libply-splash-core/ply-text-display.h \ - $(srcdir)/../libply-splash-core/ply-text-display.c \ - $(srcdir)/../libply-splash-core/ply-boot-splash.h \ - $(srcdir)/../libply-splash-core/ply-boot-splash.c |