352 lines
16 KiB
Diff
352 lines
16 KiB
Diff
From ebb1c642cd62592afc1ece9e0cf5d2ec9dfb84c0 Mon Sep 17 00:00:00 2001
|
|
From: Ray Strode <rstrode@redhat.com>
|
|
Date: Mon, 15 Oct 2018 21:56:03 -0400
|
|
Subject: [PATCH 6/6] boot-server: free the argument and triggers
|
|
|
|
coverity found some pervasive leaking of the argument
|
|
and triggers.
|
|
|
|
This commit mops them up.
|
|
---
|
|
src/ply-boot-server.c | 17 +++++++++++++++++
|
|
1 file changed, 17 insertions(+)
|
|
|
|
diff --git a/src/ply-boot-server.c b/src/ply-boot-server.c
|
|
index 3c1a268..ff0e6fd 100644
|
|
--- a/src/ply-boot-server.c
|
|
+++ b/src/ply-boot-server.c
|
|
@@ -359,60 +359,61 @@ print_connection_process_identity (ply_boot_connection_t *connection)
|
|
|
|
static void
|
|
ply_boot_connection_on_request (ply_boot_connection_t *connection)
|
|
{
|
|
ply_boot_server_t *server;
|
|
char *command, *argument;
|
|
|
|
assert (connection != NULL);
|
|
assert (connection->fd >= 0);
|
|
|
|
server = connection->server;
|
|
assert (server != NULL);
|
|
|
|
if (!ply_boot_connection_read_request (connection,
|
|
&command, &argument)) {
|
|
ply_trace ("could not read connection request");
|
|
return;
|
|
}
|
|
|
|
if (ply_is_tracing ())
|
|
print_connection_process_identity (connection);
|
|
|
|
if (!ply_boot_connection_is_from_root (connection)) {
|
|
ply_error ("request came from non-root user");
|
|
|
|
if (!ply_write (connection->fd,
|
|
PLY_BOOT_PROTOCOL_RESPONSE_TYPE_NAK,
|
|
strlen (PLY_BOOT_PROTOCOL_RESPONSE_TYPE_NAK)))
|
|
ply_trace ("could not finish writing is-not-root nak: %m");
|
|
|
|
+ free (argument);
|
|
free (command);
|
|
return;
|
|
}
|
|
|
|
if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_UPDATE) == 0) {
|
|
if (!ply_write (connection->fd,
|
|
PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK,
|
|
strlen (PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK)) &&
|
|
errno != EPIPE)
|
|
ply_trace ("could not finish writing update reply: %m");
|
|
|
|
ply_trace ("got update request");
|
|
if (server->update_handler != NULL)
|
|
server->update_handler (server->user_data, argument, server);
|
|
free (argument);
|
|
free (command);
|
|
return;
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_CHANGE_MODE) == 0) {
|
|
if (!ply_write (connection->fd,
|
|
PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK,
|
|
strlen (PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK)))
|
|
ply_trace ("could not finish writing update reply: %m");
|
|
|
|
ply_trace ("got change mode notification");
|
|
if (server->change_mode_handler != NULL)
|
|
server->change_mode_handler (server->user_data, argument, server);
|
|
free (argument);
|
|
free (command);
|
|
return;
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_SYSTEM_UPDATE) == 0) {
|
|
@@ -439,105 +440,112 @@ ply_boot_connection_on_request (ply_boot_connection_t *connection)
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_SYSTEM_INITIALIZED) == 0) {
|
|
ply_trace ("got system initialized notification");
|
|
if (server->system_initialized_handler != NULL)
|
|
server->system_initialized_handler (server->user_data, server);
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_ERROR) == 0) {
|
|
ply_trace ("got error notification");
|
|
if (server->error_handler != NULL)
|
|
server->error_handler (server->user_data, server);
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_SHOW_SPLASH) == 0) {
|
|
ply_trace ("got show splash request");
|
|
if (server->show_splash_handler != NULL)
|
|
server->show_splash_handler (server->user_data, server);
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_HIDE_SPLASH) == 0) {
|
|
ply_trace ("got hide splash request");
|
|
if (server->hide_splash_handler != NULL)
|
|
server->hide_splash_handler (server->user_data, server);
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_DEACTIVATE) == 0) {
|
|
ply_trigger_t *deactivate_trigger;
|
|
|
|
ply_trace ("got deactivate request");
|
|
|
|
deactivate_trigger = ply_trigger_new (NULL);
|
|
|
|
ply_trigger_add_handler (deactivate_trigger,
|
|
(ply_trigger_handler_t)
|
|
ply_boot_connection_on_deactivated,
|
|
connection);
|
|
|
|
if (server->deactivate_handler != NULL)
|
|
server->deactivate_handler (server->user_data, deactivate_trigger, server);
|
|
+ else
|
|
+ ply_trigger_free (deactivate_trigger);
|
|
|
|
free (argument);
|
|
free (command);
|
|
return;
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_REACTIVATE) == 0) {
|
|
ply_trace ("got reactivate request");
|
|
if (server->reactivate_handler != NULL)
|
|
server->reactivate_handler (server->user_data, server);
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_QUIT) == 0) {
|
|
bool retain_splash;
|
|
ply_trigger_t *quit_trigger;
|
|
|
|
retain_splash = (bool) argument[0];
|
|
|
|
ply_trace ("got quit %srequest", retain_splash ? "--retain-splash " : "");
|
|
|
|
quit_trigger = ply_trigger_new (NULL);
|
|
|
|
ply_trigger_add_handler (quit_trigger,
|
|
(ply_trigger_handler_t)
|
|
ply_boot_connection_on_quit_complete,
|
|
connection);
|
|
|
|
if (server->quit_handler != NULL)
|
|
server->quit_handler (server->user_data, retain_splash, quit_trigger, server);
|
|
+ else
|
|
+ ply_trigger_free (quit_trigger);
|
|
|
|
free (argument);
|
|
free (command);
|
|
return;
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_PASSWORD) == 0) {
|
|
ply_trigger_t *answer;
|
|
|
|
ply_trace ("got password request");
|
|
|
|
answer = ply_trigger_new (NULL);
|
|
ply_trigger_add_handler (answer,
|
|
(ply_trigger_handler_t)
|
|
ply_boot_connection_on_password_answer,
|
|
connection);
|
|
|
|
if (server->ask_for_password_handler != NULL) {
|
|
server->ask_for_password_handler (server->user_data,
|
|
argument,
|
|
answer,
|
|
server);
|
|
+ } else {
|
|
+ ply_trigger_free (answer);
|
|
+ free (argument);
|
|
}
|
|
/* will reply later
|
|
*/
|
|
free (command);
|
|
return;
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_CACHED_PASSWORD) == 0) {
|
|
ply_list_node_t *node;
|
|
ply_buffer_t *buffer;
|
|
size_t buffer_size;
|
|
uint32_t size;
|
|
|
|
ply_trace ("got cached password request");
|
|
|
|
buffer = ply_buffer_new ();
|
|
|
|
node = ply_list_get_first_node (server->cached_passwords);
|
|
|
|
ply_trace ("There are %d cached passwords",
|
|
ply_list_get_length (server->cached_passwords));
|
|
|
|
/* Add each answer separated by their NUL terminators into
|
|
* a buffer that we write out to the client
|
|
*/
|
|
while (node != NULL) {
|
|
ply_list_node_t *next_node;
|
|
const char *password;
|
|
|
|
next_node = ply_list_get_next_node (server->cached_passwords, node);
|
|
password = (const char *) ply_list_node_get_data (node);
|
|
|
|
@@ -565,146 +573,155 @@ ply_boot_connection_on_request (ply_boot_connection_t *connection)
|
|
ply_list_get_length (server->cached_passwords));
|
|
if (!ply_write (connection->fd,
|
|
PLY_BOOT_PROTOCOL_RESPONSE_TYPE_MULTIPLE_ANSWERS,
|
|
strlen (PLY_BOOT_PROTOCOL_RESPONSE_TYPE_MULTIPLE_ANSWERS)) ||
|
|
!ply_write_uint32 (connection->fd,
|
|
size) ||
|
|
!ply_write (connection->fd,
|
|
ply_buffer_get_bytes (buffer), size))
|
|
ply_trace ("could not finish writing cached answer reply: %m");
|
|
}
|
|
|
|
ply_buffer_free (buffer);
|
|
free (command);
|
|
return;
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_QUESTION) == 0) {
|
|
ply_trigger_t *answer;
|
|
|
|
ply_trace ("got question request");
|
|
|
|
answer = ply_trigger_new (NULL);
|
|
ply_trigger_add_handler (answer,
|
|
(ply_trigger_handler_t)
|
|
ply_boot_connection_on_question_answer,
|
|
connection);
|
|
|
|
if (server->ask_question_handler != NULL) {
|
|
server->ask_question_handler (server->user_data,
|
|
argument,
|
|
answer,
|
|
server);
|
|
+ } else {
|
|
+ ply_trigger_free (answer);
|
|
+ free (argument);
|
|
}
|
|
/* will reply later
|
|
*/
|
|
free (command);
|
|
return;
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_SHOW_MESSAGE) == 0) {
|
|
ply_trace ("got show message request");
|
|
if (server->display_message_handler != NULL)
|
|
server->display_message_handler (server->user_data, argument, server);
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_HIDE_MESSAGE) == 0) {
|
|
ply_trace ("got hide message request");
|
|
if (server->hide_message_handler != NULL)
|
|
server->hide_message_handler (server->user_data, argument, server);
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_KEYSTROKE) == 0) {
|
|
ply_trigger_t *answer;
|
|
|
|
ply_trace ("got keystroke request");
|
|
|
|
answer = ply_trigger_new (NULL);
|
|
ply_trigger_add_handler (answer,
|
|
(ply_trigger_handler_t)
|
|
ply_boot_connection_on_keystroke_answer,
|
|
connection);
|
|
|
|
if (server->watch_for_keystroke_handler != NULL) {
|
|
server->watch_for_keystroke_handler (server->user_data,
|
|
argument,
|
|
answer,
|
|
server);
|
|
+ } else {
|
|
+ ply_trigger_free (answer);
|
|
+ free (argument);
|
|
}
|
|
/* will reply later
|
|
*/
|
|
free (command);
|
|
return;
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_KEYSTROKE_REMOVE) == 0) {
|
|
ply_trace ("got keystroke remove request");
|
|
if (server->ignore_keystroke_handler != NULL)
|
|
server->ignore_keystroke_handler (server->user_data,
|
|
argument,
|
|
server);
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_PROGRESS_PAUSE) == 0) {
|
|
ply_trace ("got progress pause request");
|
|
if (server->progress_pause_handler != NULL)
|
|
server->progress_pause_handler (server->user_data,
|
|
server);
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_PROGRESS_UNPAUSE) == 0) {
|
|
ply_trace ("got progress unpause request");
|
|
if (server->progress_unpause_handler != NULL)
|
|
server->progress_unpause_handler (server->user_data,
|
|
server);
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_NEWROOT) == 0) {
|
|
ply_trace ("got newroot request");
|
|
if (server->newroot_handler != NULL)
|
|
server->newroot_handler (server->user_data, argument, server);
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_HAS_ACTIVE_VT) == 0) {
|
|
bool answer = false;
|
|
|
|
ply_trace ("got has_active vt? request");
|
|
if (server->has_active_vt_handler != NULL)
|
|
answer = server->has_active_vt_handler (server->user_data, server);
|
|
|
|
if (!answer) {
|
|
if (!ply_write (connection->fd,
|
|
PLY_BOOT_PROTOCOL_RESPONSE_TYPE_NAK,
|
|
strlen (PLY_BOOT_PROTOCOL_RESPONSE_TYPE_NAK)))
|
|
ply_trace ("could not finish writing nak: %m");
|
|
|
|
+ free (argument);
|
|
free (command);
|
|
return;
|
|
}
|
|
} else if (strcmp (command, PLY_BOOT_PROTOCOL_REQUEST_TYPE_PING) != 0) {
|
|
ply_error ("received unknown command '%s' from client", command);
|
|
|
|
if (!ply_write (connection->fd,
|
|
PLY_BOOT_PROTOCOL_RESPONSE_TYPE_NAK,
|
|
strlen (PLY_BOOT_PROTOCOL_RESPONSE_TYPE_NAK)))
|
|
ply_trace ("could not finish writing ping reply: %m");
|
|
|
|
+ free (argument);
|
|
free (command);
|
|
return;
|
|
}
|
|
|
|
if (!ply_write (connection->fd,
|
|
PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK,
|
|
strlen (PLY_BOOT_PROTOCOL_RESPONSE_TYPE_ACK)))
|
|
ply_trace ("could not finish writing ack: %m");
|
|
+ free (argument);
|
|
free (command);
|
|
}
|
|
|
|
static void
|
|
ply_boot_connection_on_hangup (ply_boot_connection_t *connection)
|
|
{
|
|
ply_list_node_t *node;
|
|
ply_boot_server_t *server;
|
|
|
|
assert (connection != NULL);
|
|
assert (connection->server != NULL);
|
|
|
|
server = connection->server;
|
|
|
|
node = ply_list_find_node (server->connections, connection);
|
|
|
|
assert (node != NULL);
|
|
|
|
ply_boot_connection_free (connection);
|
|
ply_list_remove_node (server->connections, node);
|
|
}
|
|
|
|
static void
|
|
ply_boot_server_on_new_connection (ply_boot_server_t *server)
|
|
{
|
|
ply_boot_connection_t *connection;
|
|
int fd;
|
|
|
|
assert (server != NULL);
|
|
|
|
--
|
|
2.17.1
|
|
|