X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=ui%2Fcommon%2Fdiscover-client.c;h=6247dd0471b6b5fa6f8247adb68f872297eb6c52;hp=cd9f63a9f68f584bcc5b3f26976fd6d73269ad11;hb=ec82dfa6207090d285c4617e1d0a7a2284e390c3;hpb=39bfdc44fdbc8091afa512bf44c70ac1b3ba15d4 diff --git a/ui/common/discover-client.c b/ui/common/discover-client.c index cd9f63a..6247dd0 100644 --- a/ui/common/discover-client.c +++ b/ui/common/discover-client.c @@ -1,4 +1,5 @@ +#include #include #include #include @@ -32,53 +33,23 @@ static int discover_client_destructor(void *arg) return 0; } -struct discover_client* discover_client_init( - const struct discover_client_ops *ops, void *cb_arg) +void discover_client_destroy(struct discover_client *client) { - struct discover_client *client; - struct sockaddr_un addr; - - client = talloc(NULL, struct discover_client); - if (!client) - return NULL; - - memcpy(&client->ops, ops, sizeof(client->ops)); - client->ops.cb_arg = cb_arg; - - client->fd = socket(AF_UNIX, SOCK_STREAM, 0); - if (client->fd < 0) { - pb_log("%s: socket: %s\n", __func__, strerror(errno)); - goto out_err; - } - - talloc_set_destructor(client, discover_client_destructor); - - client->n_devices = 0; - client->devices = NULL; - - addr.sun_family = AF_UNIX; - 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)); - goto out_err; - } - - return client; - -out_err: talloc_free(client); - return NULL; } -int discover_client_get_fd(const struct discover_client *client) +static struct device *find_device(struct discover_client *client, + const char *id) { - return client->fd; -} + int i; -void discover_client_destroy(struct discover_client *client) -{ - talloc_free(client); + for (i = 0; i < client->n_devices; i++) { + struct device *dev = client->devices[i]; + if (!strcmp(dev->id, id)) + return dev; + } + + return NULL; } static void device_add(struct discover_client *client, struct device *device) @@ -89,8 +60,28 @@ 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); - client->ops.device_add(device, client->ops.cb_arg); + if (client->ops.device_add) + client->ops.device_add(device, client->ops.cb_arg); +} + +static void boot_option_add(struct discover_client *client, + struct boot_option *opt) +{ + struct device *dev; + + dev = find_device(client, opt->device_id); + + /* we require that devices are already present before any boot options + * are added */ + 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); } static void device_remove(struct discover_client *client, const char *id) @@ -121,43 +112,181 @@ static void device_remove(struct discover_client *client, const char *id) talloc_free(device); } -int discover_client_process(struct discover_client *client) +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) +{ + if (client->ops.update_status) + client->ops.update_status(status, client->ops.cb_arg); +} + +static void update_sysinfo(struct discover_client *client, + struct system_info *sysinfo) +{ + if (client->ops.update_sysinfo) + client->ops.update_sysinfo(sysinfo, client->ops.cb_arg); +} + +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 system_info *sysinfo; + struct boot_status *status; + struct boot_option *opt; + struct config *config; struct device *dev; char *dev_id; + void *ctx; + int rc; + + /* 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(client, client->fd); + message = pb_protocol_read_message(ctx, client->fd); if (!message) return -1; switch (message->action) { - case PB_PROTOCOL_ACTION_ADD: - dev = pb_protocol_deserialise_device(client, message); - if (!dev) { + case PB_PROTOCOL_ACTION_DEVICE_ADD: + 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; + goto out; } device_add(client, dev); break; - case PB_PROTOCOL_ACTION_REMOVE: - dev_id = pb_protocol_deserialise_string(client, message); + case PB_PROTOCOL_ACTION_BOOT_OPTION_ADD: + 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__); + goto out; + } + + boot_option_add(client, opt); + break; + case PB_PROTOCOL_ACTION_DEVICE_REMOVE: + dev_id = pb_protocol_deserialise_string(ctx, message); if (!dev_id) { pb_log("%s: no device id?\n", __func__); - return 0; + goto out; } device_remove(client, dev_id); break; + case PB_PROTOCOL_ACTION_STATUS: + status = talloc_zero(ctx, struct boot_status); + + rc = pb_protocol_deserialise_boot_status(status, message); + if (rc) { + pb_log("%s: invalid status message?\n", __func__); + goto out; + } + update_status(client, status); + break; + case PB_PROTOCOL_ACTION_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__); + 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("%s: invalid config message?\n", __func__); + goto out; + } + update_config(client, config); + break; default: pb_log("%s: unknown action %d\n", __func__, message->action); } +out: + talloc_free(ctx); return 0; } +struct discover_client* discover_client_init(struct waitset *waitset, + const struct discover_client_ops *ops, void *cb_arg) +{ + struct discover_client *client; + struct sockaddr_un addr; + + client = talloc(NULL, struct discover_client); + if (!client) + return NULL; + + memcpy(&client->ops, ops, sizeof(client->ops)); + client->ops.cb_arg = cb_arg; + + client->fd = socket(AF_UNIX, SOCK_STREAM, 0); + if (client->fd < 0) { + pb_log("%s: socket: %s\n", __func__, strerror(errno)); + goto out_err; + } + + talloc_set_destructor(client, discover_client_destructor); + + client->n_devices = 0; + client->devices = NULL; + + addr.sun_family = AF_UNIX; + 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)); + goto out_err; + } + + waiter_register_io(waitset, client->fd, WAIT_IN, + discover_client_process, client); + + return client; + +out_err: + talloc_free(client); + return NULL; +} + /* accessors for discovered devices */ int discover_client_device_count(struct discover_client *client) { @@ -172,3 +301,105 @@ struct device *discover_client_get_device(struct discover_client *client, return client->devices[index]; } + +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 ? 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->tty = ttyname(STDIN_FILENO); +} + +int discover_client_boot(struct discover_client *client, + const struct device *device, + const struct boot_option *boot_option, + const struct pb_boot_data *data) +{ + struct pb_protocol_message *message; + struct boot_command boot_command; + int len, rc; + + create_boot_command(&boot_command, device, boot_option, data); + + len = pb_protocol_boot_len(&boot_command); + + message = pb_protocol_create_message(client, + PB_PROTOCOL_ACTION_BOOT, len); + + if (!message) + return -1; + + pb_protocol_serialise_boot_command(&boot_command, + message->payload, len); + + rc = pb_protocol_write_message(client->fd, message); + + return rc; +} + +int discover_client_cancel_default(struct discover_client *client) +{ + struct pb_protocol_message *message; + + message = pb_protocol_create_message(client, + PB_PROTOCOL_ACTION_CANCEL_DEFAULT, 0); + + if (!message) + return -1; + + 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); +}