static void
on_password_answer_failure (password_answer_state_t *answer_state,
ply_boot_client_t *client)
{
ply_trace ("password answer failure");
/* plymouthd isn't running for some reason. If there is a command
* to run, we'll run it anyway, because it might be important for
* boot up to continue (to decrypt the root partition or whatever)
*/
if (answer_state->command != NULL)
{
int exit_status;
bool command_started;
ply_trace ("daemon not available, running command on our own");
exit_status = 127;
command_started = false;
while (answer_state->number_of_tries_left > 0)
{
command_started = answer_via_command (answer_state->command, NULL,
&exit_status);
if (command_started && WIFEXITED (exit_status) &&
WEXITSTATUS (exit_status) == 0)
{
ply_trace ("command was successful");
break;
}
ply_trace ("command failed");
answer_state->number_of_tries_left--;
}
if (command_started && WIFSIGNALED (exit_status))
{
ply_trace ("command died with signal %s", strsignal (WTERMSIG (exit_status)));
raise (WTERMSIG (exit_status));
}
else
{
ply_event_loop_exit (answer_state->state->loop,
WEXITSTATUS (exit_status));
}
}
else
{
ply_event_loop_exit (answer_state->state->loop, 1);
}
}
static void
on_key_answer (key_answer_state_t *answer_state,
const char *answer,
ply_boot_client_t *client)
{
if (answer_state->command != NULL)
{
answer_via_command (answer_state->command, answer, NULL);
}
else
{
if (answer != NULL)
write (STDOUT_FILENO, answer, strlen (answer));
}
if (answer != NULL)
ply_event_loop_exit (answer_state->state->loop, 0);
ply_event_loop_exit (answer_state->state->loop, 1);
}
static void
on_question_answer (question_answer_state_t *answer_state,
const char *answer,
ply_boot_client_t *client)
{
if (answer != NULL)
{
if (answer_state->command != NULL)
{
answer_via_command (answer_state->command, answer, NULL);
}
else
{
write (STDOUT_FILENO, answer, strlen (answer));
}
if (answer_state->pause)
ply_boot_client_tell_daemon_to_progress_unpause (client,
(ply_boot_client_response_handler_t)
on_success,
(ply_boot_client_response_handler_t)
on_failure,
answer_state->state);
else
ply_event_loop_exit (answer_state->state->loop, 0);
}
else
{
if (answer_state->pause)
ply_boot_client_tell_daemon_to_progress_unpause (client,
(ply_boot_client_response_handler_t)
on_failure,
(ply_boot_client_response_handler_t)
on_failure,
answer_state->state);
else
ply_event_loop_exit (answer_state->state->loop, 1);
}
}
static void
on_multiple_password_answers (password_answer_state_t *answer_state,
const char * const *answers)
{
bool need_to_ask_user;
int i;
int exit_status;
assert (answer_state->command != NULL);
ply_trace ("on multiple password answers");
need_to_ask_user = true;
if (answers != NULL)
{
ply_trace ("daemon has a few candidate passwords for us to try");
for (i = 0; answers[i] != NULL; i++)
{
bool command_started;
exit_status = 127;
command_started = answer_via_command (answer_state->command, answers[i],
&exit_status);
if (command_started && WIFEXITED (exit_status) &&
WEXITSTATUS (exit_status) == 0)
{
need_to_ask_user = false;
break;
}
}
}
else
{
ply_trace ("daemon has no candidate passwords for us to try");
}
if (need_to_ask_user)
{
ply_boot_client_ask_daemon_for_password (answer_state->state->client,
answer_state->prompt,
(ply_boot_client_answer_handler_t)
on_password_answer,
(ply_boot_client_response_handler_t)
on_password_answer_failure, answer_state);
return;
}
ply_event_loop_exit (answer_state->state->loop, 0);
}
Plymouth::answer_t Plymouth::displayMessage(const std::string & message){
ply_boot_client_attach_to_event_loop(_ply_client, _ply_event_loop);
auto response_helper = [this] (int exit_status) -> void {
ply_event_loop_exit(_ply_event_loop, exit_status);
};
typedef decltype(response_helper) answer_helper_t;
auto response_hdl = [] (void * data, ply_boot_client_t *) -> void{
(*reinterpret_cast<answer_helper_t*>(data))(OK);
};
auto fail_hdl = [] (void *data, ply_boot_client_t*) -> void{
(*reinterpret_cast<answer_helper_t*>(data))(FAILED);
};
ply_boot_client_tell_daemon_to_display_message(_ply_client, message.c_str(), response_hdl, fail_hdl, &response_helper);
return static_cast<answer_t>(ply_event_loop_run(_ply_event_loop));
}
static void
on_disconnect (state_t *state)
{
bool wait;
int status = 0;
wait = false;
ply_command_parser_get_options (state->command_parser,
"wait", &wait,
NULL
);
if (! wait) {
ply_error ("error: unexpectedly disconnected from boot status daemon");
status = 2;
}
ply_trace ("disconnect");
ply_event_loop_exit (state->loop, status);
}
Plymouth::answer_t Plymouth::pause(bool do_pause){
ply_boot_client_attach_to_event_loop(_ply_client, _ply_event_loop);
auto response_helper = [this] (int exit_status) -> void {
ply_event_loop_exit(_ply_event_loop, exit_status);
};
typedef decltype(response_helper) answer_helper_t;
auto success_hdl = [] (void * data, ply_boot_client_t *) -> void{
(*reinterpret_cast<answer_helper_t*>(data))(OK);
};
auto fail_hdl = [] (void *data, ply_boot_client_t*) -> void{
(*reinterpret_cast<answer_helper_t*>(data))(FAILED);
};
if (do_pause){
ply_boot_client_tell_daemon_to_progress_pause(_ply_client, success_hdl, fail_hdl, &response_helper);
} else {
ply_boot_client_tell_daemon_to_progress_unpause(_ply_client, success_hdl, fail_hdl, &response_helper);
}
return static_cast<answer_t>(ply_event_loop_run(_ply_event_loop));
}
Plymouth::answer_t Plymouth::askQuestion(const std::string & prompt, std::string & answer){
ply_boot_client_attach_to_event_loop(_ply_client, _ply_event_loop);
auto answer_helper = [this, &answer] (const char * _answer, int exit_status) -> void {
if(_answer == 0 || _answer[0] == KEY_CTRL_C){
exit_status = CANCELED;
}
if(exit_status == OK){
answer.assign(_answer);
}
ply_event_loop_exit(_ply_event_loop, exit_status);
};
typedef decltype(answer_helper) answer_helper_t;
auto answer_hdl = [] (void * data, const char * answer, ply_boot_client_t *) -> void{
(*reinterpret_cast<answer_helper_t*>(data))(answer, OK);
};
auto fail_hdl = [] (void *data, ply_boot_client_t*) -> void{
(*reinterpret_cast<answer_helper_t*>(data))("", FAILED);
};
ply_boot_client_ask_daemon_question(_ply_client, prompt.c_str(), answer_hdl, fail_hdl, &answer_helper);
return static_cast<answer_t>(ply_event_loop_run(_ply_event_loop));
}
Plymouth::answer_t Plymouth::whatchKey(const std::string & keys, std::string & result){
ply_boot_client_attach_to_event_loop(_ply_client, _ply_event_loop);
auto answer_helper = [this, &result] (const char * _answer, int exit_status) -> void {
if(_answer == 0){
exit_status = CANCELED;
}
if(exit_status == OK){
result.assign(_answer);
}
ply_event_loop_exit(_ply_event_loop, exit_status);
};
typedef decltype(answer_helper) answer_helper_t;
auto answer_hdl = [] (void * data, const char * answer, ply_boot_client_t *) -> void{
(*reinterpret_cast<answer_helper_t*>(data))(answer, OK);
};
auto fail_hdl = [] (void *data, ply_boot_client_t*) -> void{
(*reinterpret_cast<answer_helper_t*>(data))("", FAILED);
};
ply_boot_client_ask_daemon_to_watch_for_keystroke(_ply_client, keys == "" ? 0 : keys.c_str(), answer_hdl, fail_hdl, &answer_helper);
return static_cast<answer_t>(ply_event_loop_run(_ply_event_loop));
}
static void
on_disconnect (ply_event_loop_t *loop)
{
printf ("DISCONNECT!\n");
ply_event_loop_exit (loop, 1);
}
static void
on_quit_failed (ply_event_loop_t *loop)
{
printf ("QUIT FAILED! %m\n");
ply_event_loop_exit (loop, 2);
}
static void
on_quit (ply_event_loop_t *loop)
{
printf ("QUIT!\n");
ply_event_loop_exit (loop, 0);
}
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_update_failed (ply_event_loop_t *loop)
{
printf ("UPDATE FAILED! %m\n");
ply_event_loop_exit (loop, 1);
}
static void
on_ping_failed (ply_event_loop_t *loop)
{
printf ("PING FAILED! %m\n");
ply_event_loop_exit (loop, 1);
}
static void on_disconnect(void* dummy)
{
ply_event_loop_exit(ply_loop, 0);
}
static void on_failure(void* dummy)
{
ply_event_loop_exit(ply_loop, 0);
}
static void
on_password_answer (password_answer_state_t *answer_state,
const char *answer,
ply_boot_client_t *client)
{
int exit_status;
exit_status = 127;
if (answer != NULL && answer[0] != KEY_CTRL_C) /* a CTRL-C answer means the user canceled */
{
if (answer_state->command != NULL)
{
bool command_started = false;
command_started = answer_via_command (answer_state->command, answer,
&exit_status);
if (command_started && (!WIFEXITED (exit_status) ||
WEXITSTATUS (exit_status) != 0))
{
answer_state->number_of_tries_left--;
if (answer_state->number_of_tries_left > 0)
{
ply_boot_client_ask_daemon_for_password (answer_state->state->client,
answer_state->prompt,
(ply_boot_client_answer_handler_t)
on_password_answer,
(ply_boot_client_response_handler_t)
on_password_answer_failure,
answer_state);
return;
}
}
}
else
{
write (STDOUT_FILENO, answer, strlen (answer));
exit_status = 0;
}
}
else if (answer == NULL)
{
on_password_answer_failure (answer_state, answer_state->state->client);
}
if (WIFSIGNALED (exit_status))
raise (WTERMSIG (exit_status));
if (answer_state->pause)
{
ply_boot_client_tell_daemon_to_progress_unpause (client,
(ply_boot_client_response_handler_t)
(WEXITSTATUS (exit_status) ? on_failure : on_success),
(ply_boot_client_response_handler_t)
on_failure,
answer_state->state);
}
else
ply_event_loop_exit (answer_state->state->loop, WEXITSTATUS (exit_status));
}
static void
on_success (state_t *state)
{
ply_event_loop_exit (state->loop, 0);
}
static void
on_quit (ply_event_loop_t *loop)
{
printf ("got quit request, quiting...\n");
ply_event_loop_exit (loop, 0);
}
static void
on_disconnect (state_t *state)
{
ply_trace ("disconnected from boot status daemon");
ply_event_loop_exit (state->loop, 0);
}
static void
on_key_answer_failure (key_answer_state_t *answer_state,
ply_boot_client_t *client)
{
ply_event_loop_exit (answer_state->state->loop, 1);
}
static void
on_interrupt (ply_boot_splash_plugin_t *plugin)
{
ply_event_loop_exit (plugin->loop, 1);
stop_animation (plugin, NULL);
}
static void
on_failure (state_t *state)
{
ply_event_loop_exit (state->loop, 1);
}
