X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=ui%2Fcommon%2Fdiscover-client.c;h=e7dfb831ba6b586ab311607128abb47e92890e8d;hp=90cd3b419101c051e35f5da1539eb975673c22ee;hb=9011b958364f2af965a33681e7375f079ba75d02;hpb=bc4114e2235163bd88456c25cc0a908d86151f93 diff --git a/ui/common/discover-client.c b/ui/common/discover-client.c index 90cd3b4..e7dfb83 100644 --- a/ui/common/discover-client.c +++ b/ui/common/discover-client.c @@ -1,10 +1,15 @@ +#if defined(HAVE_CONFIG_H) +#include "config.h" +#endif + #include #include #include #include #include #include +#include #include #include @@ -21,6 +26,7 @@ struct discover_client { struct discover_client_ops ops; int n_devices; struct device **devices; + bool authenticated; }; static int discover_client_destructor(void *arg) @@ -60,6 +66,7 @@ static void device_add(struct discover_client *client, struct device *device) client->devices[client->n_devices - 1] = device; talloc_steal(client, device); + list_init(&device->boot_options); if (client->ops.device_add) client->ops.device_add(device, client->ops.cb_arg); @@ -77,6 +84,7 @@ static void boot_option_add(struct discover_client *client, assert(dev); talloc_steal(dev, opt); + list_add(&dev->boot_options, &opt->list); if (client->ops.boot_option_add) client->ops.boot_option_add(dev, opt, client->ops.cb_arg); @@ -110,12 +118,44 @@ static void device_remove(struct discover_client *client, const char *id) talloc_free(device); } +static void plugin_option_add(struct discover_client *client, + struct plugin_option *opt) +{ + talloc_steal(client, opt); + + if (client->ops.plugin_option_add) + client->ops.plugin_option_add(opt, client->ops.cb_arg); +} + +static void plugins_remove(struct discover_client *client) +{ + if (client->ops.plugins_remove) + client->ops.plugins_remove(client->ops.cb_arg); +} + +void discover_client_enumerate(struct discover_client *client) +{ + struct boot_option *opt; + struct device *device; + int i; + + for (i = 0; i < client->n_devices; i++) { + device = client->devices[i]; + if (client->ops.device_add) + client->ops.device_add(device, client->ops.cb_arg); + + list_for_each_entry(&device->boot_options, opt, list) + if (client->ops.boot_option_add) + client->ops.boot_option_add(device, opt, + client->ops.cb_arg); + } +} + static void update_status(struct discover_client *client, - struct boot_status *status) + struct status *status) { if (client->ops.update_status) client->ops.update_status(status, client->ops.cb_arg); - talloc_free(status); } static void update_sysinfo(struct discover_client *client, @@ -123,81 +163,135 @@ static void update_sysinfo(struct discover_client *client, { if (client->ops.update_sysinfo) client->ops.update_sysinfo(sysinfo, client->ops.cb_arg); - talloc_free(sysinfo); +} + +static void update_config(struct discover_client *client, + struct config *config) +{ + if (client->ops.update_config) + client->ops.update_config(config, client->ops.cb_arg); } static int discover_client_process(void *arg) { struct discover_client *client = arg; struct pb_protocol_message *message; + struct auth_message *auth_msg; + struct plugin_option *p_opt; struct system_info *sysinfo; - struct boot_status *status; struct boot_option *opt; + struct status *status; + struct config *config; struct device *dev; char *dev_id; + void *ctx; int rc; - message = pb_protocol_read_message(client, client->fd); + /* We use a temporary context for processing one message; persistent + * data is re-parented to the client in the callbacks. */ + ctx = talloc_new(client); + + message = pb_protocol_read_message(ctx, client->fd); if (!message) return -1; switch (message->action) { case PB_PROTOCOL_ACTION_DEVICE_ADD: - dev = talloc_zero(client, struct device); + dev = talloc_zero(ctx, struct device); list_init(&dev->boot_options); rc = pb_protocol_deserialise_device(dev, message); if (rc) { - pb_log("%s: no device?\n", __func__); - return 0; + pb_log_fn("no device?\n"); + goto out; } device_add(client, dev); break; case PB_PROTOCOL_ACTION_BOOT_OPTION_ADD: - opt = talloc_zero(client, struct boot_option); + opt = talloc_zero(ctx, struct boot_option); rc = pb_protocol_deserialise_boot_option(opt, message); if (rc) { - pb_log("%s: no boot_option?\n", __func__); - return 0; + pb_log_fn("no boot_option?\n"); + goto out; } boot_option_add(client, opt); break; case PB_PROTOCOL_ACTION_DEVICE_REMOVE: - dev_id = pb_protocol_deserialise_string(client, message); + dev_id = pb_protocol_deserialise_string(ctx, message); if (!dev_id) { - pb_log("%s: no device id?\n", __func__); - return 0; + pb_log_fn("no device id?\n"); + goto out; } device_remove(client, dev_id); break; case PB_PROTOCOL_ACTION_STATUS: - status = talloc_zero(client, struct boot_status); + status = talloc_zero(ctx, struct status); rc = pb_protocol_deserialise_boot_status(status, message); if (rc) { - pb_log("%s: invalid status message?\n", __func__); - return 0; + pb_log_fn("invalid status message?\n"); + goto out; } update_status(client, status); break; case PB_PROTOCOL_ACTION_SYSTEM_INFO: - sysinfo = talloc_zero(client, struct system_info); + sysinfo = talloc_zero(ctx, struct system_info); rc = pb_protocol_deserialise_system_info(sysinfo, message); if (rc) { - pb_log("%s: invalid sysinfo message?\n", __func__); - return 0; + pb_log_fn("invalid sysinfo message?\n"); + goto out; } update_sysinfo(client, sysinfo); break; + case PB_PROTOCOL_ACTION_CONFIG: + config = talloc_zero(ctx, struct config); + + rc = pb_protocol_deserialise_config(config, message); + if (rc) { + pb_log_fn("invalid config message?\n"); + goto out; + } + update_config(client, config); + break; + case PB_PROTOCOL_ACTION_PLUGIN_OPTION_ADD: + p_opt = talloc_zero(ctx, struct plugin_option); + + rc = pb_protocol_deserialise_plugin_option(p_opt, message); + if (rc) { + pb_log_fn("no plugin_option?\n"); + goto out; + } + + plugin_option_add(client, p_opt); + break; + case PB_PROTOCOL_ACTION_PLUGINS_REMOVE: + plugins_remove(client); + break; + case PB_PROTOCOL_ACTION_AUTHENTICATE: + auth_msg = talloc_zero(ctx, struct auth_message); + + rc = pb_protocol_deserialise_authenticate(auth_msg, message); + if (rc || auth_msg->op != AUTH_MSG_RESPONSE) { + pb_log("%s: invalid auth message? (%d)\n", + __func__, rc); + goto out; + } + + pb_log("Client %sauthenticated by server\n", + client->authenticated ? "" : "un"); + client->authenticated = auth_msg->authenticated; + break; default: - pb_log("%s: unknown action %d\n", __func__, message->action); + pb_log_fn("unknown action %d\n", message->action); } +out: + talloc_free(ctx); return 0; } @@ -217,7 +311,7 @@ struct discover_client* discover_client_init(struct waitset *waitset, client->fd = socket(AF_UNIX, SOCK_STREAM, 0); if (client->fd < 0) { - pb_log("%s: socket: %s\n", __func__, strerror(errno)); + pb_log_fn("socket: %s\n", strerror(errno)); goto out_err; } @@ -230,13 +324,20 @@ struct discover_client* discover_client_init(struct waitset *waitset, strcpy(addr.sun_path, PB_SOCKET_PATH); if (connect(client->fd, (struct sockaddr *)&addr, sizeof(addr))) { - pb_log("%s: connect: %s\n", __func__, strerror(errno)); + pb_log_fn("connect: %s\n", strerror(errno)); goto out_err; } waiter_register_io(waitset, client->fd, WAIT_IN, discover_client_process, client); + /* Assume this client can't make changes if crypt support is enabled */ +#ifdef CRYPT_SUPPORT + client->authenticated = false; +#else + client->authenticated = true; +#endif + return client; out_err: @@ -259,17 +360,23 @@ struct device *discover_client_get_device(struct discover_client *client, return client->devices[index]; } +bool discover_client_authenticated(struct discover_client *client) +{ + return client->authenticated; +} + static void create_boot_command(struct boot_command *command, const struct device *device __attribute__((unused)), const struct boot_option *boot_option, const struct pb_boot_data *data) { - - command->option_id = boot_option->id; + command->option_id = boot_option ? boot_option->id : NULL; command->boot_image_file = data->image; command->initrd_file = data->initrd; command->dtb_file = data->dtb; command->boot_args = data->args; + command->args_sig_file = data->args_sig_file; + command->console = ttyname(STDIN_FILENO); } int discover_client_boot(struct discover_client *client, @@ -311,3 +418,137 @@ int discover_client_cancel_default(struct discover_client *client) return pb_protocol_write_message(client->fd, message); } + +int discover_client_send_reinit(struct discover_client *client) +{ + struct pb_protocol_message *message; + + message = pb_protocol_create_message(client, + PB_PROTOCOL_ACTION_REINIT, 0); + + if (!message) + return -1; + + return pb_protocol_write_message(client->fd, message); +} + +int discover_client_send_config(struct discover_client *client, + struct config *config) +{ + struct pb_protocol_message *message; + int len; + + len = pb_protocol_config_len(config); + + message = pb_protocol_create_message(client, + PB_PROTOCOL_ACTION_CONFIG, len); + if (!message) + return -1; + + pb_protocol_serialise_config(config, message->payload, len); + + return pb_protocol_write_message(client->fd, message); +} + +int discover_client_send_url(struct discover_client *client, + char *url) +{ + struct pb_protocol_message *message; + int len; + + len = pb_protocol_url_len(url); + + message = pb_protocol_create_message(client, + PB_PROTOCOL_ACTION_ADD_URL, len); + if (!message) + return -1; + + pb_protocol_serialise_url(url, message->payload, len); + + return pb_protocol_write_message(client->fd, message); +} + +int discover_client_send_plugin_install(struct discover_client *client, + char *file) +{ + struct pb_protocol_message *message; + int len; + + len = pb_protocol_url_len(file); + + message = pb_protocol_create_message(client, + PB_PROTOCOL_ACTION_PLUGIN_INSTALL, len); + if (!message) + return -1; + + pb_protocol_serialise_url(file, message->payload, len); + + return pb_protocol_write_message(client->fd, message); +} + +int discover_client_send_temp_autoboot(struct discover_client *client, + const struct autoboot_option *opt) +{ + struct pb_protocol_message *message; + int len; + + len = pb_protocol_temp_autoboot_len(opt); + + message = pb_protocol_create_message(client, + PB_PROTOCOL_ACTION_TEMP_AUTOBOOT, len); + if (!message) + return -1; + + pb_protocol_serialise_temp_autoboot(opt, message->payload, len); + + return pb_protocol_write_message(client->fd, message); +} + +int discover_client_send_authenticate(struct discover_client *client, + char *password) +{ + struct pb_protocol_message *message; + struct auth_message auth_msg; + int len; + + auth_msg.op = AUTH_MSG_REQUEST; + auth_msg.password = password; + + len = pb_protocol_authenticate_len(&auth_msg); + + message = pb_protocol_create_message(client, + PB_PROTOCOL_ACTION_AUTHENTICATE, len); + if (!message) + return -1; + + pb_log("serialising auth message..\n"); + pb_protocol_serialise_authenticate(&auth_msg, message->payload, len); + + pb_log("sending auth message..\n"); + return pb_protocol_write_message(client->fd, message); +} + +int discover_client_send_set_password(struct discover_client *client, + char *password, char *new_password) +{ + struct pb_protocol_message *message; + struct auth_message auth_msg; + int len; + + auth_msg.op = AUTH_MSG_SET; + auth_msg.set_password.password = password; + auth_msg.set_password.new_password = new_password; + + len = pb_protocol_authenticate_len(&auth_msg); + + message = pb_protocol_create_message(client, + PB_PROTOCOL_ACTION_AUTHENTICATE, len); + if (!message) + return -1; + + pb_log("serialising auth message..\n"); + pb_protocol_serialise_authenticate(&auth_msg, message->payload, len); + + pb_log("sending auth message..\n"); + return pb_protocol_write_message(client->fd, message); +}