protocol: Add block device information to system info
[petitboot] / lib / pb-protocol / pb-protocol.c
index 2792bf832c7ea2866a6accbe3b82b191eaa406f4..091fab722f102e9d9c186e8bec6900146737bcce 100644 (file)
@@ -2,6 +2,7 @@
 #include <assert.h>
 #include <errno.h>
 #include <string.h>
+#include <stdbool.h>
 #include <stdint.h>
 #include <asm/byteorder.h>
 
@@ -21,6 +22,7 @@
  * action = 0x1: device add message
  *  payload:
  *   4-byte len, id
+ *   1-byte type
  *   4-byte len, name
  *   4-byte len, description
  *   4-byte len, icon_file
@@ -33,6 +35,7 @@
  *    4-byte len, icon_file
  *    4-byte len, boot_image_file
  *    4-byte len, initrd_file
+ *    4-byte len, dtb_file
  *    4-byte len, boot_args
  *
  * action = 0x2: device remove message
@@ -44,6 +47,7 @@
  *   4-byte len, boot option id
  *   4-byte len, boot_image_file
  *   4-byte len, initrd_file
+ *   4-byte len, dtb_file
  *   4-byte len, boot_args
  *
  */
@@ -66,6 +70,7 @@ void pb_protocol_dump_device(const struct device *dev, const char *text,
                fprintf(stream, "%s\t\ticon: %s\n", text, opt->icon_file);
                fprintf(stream, "%s\t\tboot: %s\n", text, opt->boot_image_file);
                fprintf(stream, "%s\t\tinit: %s\n", text, opt->initrd_file);
+               fprintf(stream, "%s\t\tdtb:  %s\n", text, opt->dtb_file);
                fprintf(stream, "%s\t\targs: %s\n", text, opt->boot_args);
        }
 }
@@ -136,6 +141,18 @@ static int read_string(void *ctx, const char **pos, unsigned int *len,
        return 0;
 }
 
+static int read_u32(const char **pos, unsigned int *len, unsigned int *p)
+{
+       if (*len < sizeof(uint32_t))
+               return -1;
+
+       *p = (unsigned int)__be32_to_cpu(*(uint32_t *)(*pos));
+       *pos += sizeof(uint32_t);
+       *len -= sizeof(uint32_t);
+
+       return 0;
+}
+
 char *pb_protocol_deserialise_string(void *ctx,
                const struct pb_protocol_message *message)
 {
@@ -162,6 +179,7 @@ static int optional_strlen(const char *str)
 int pb_protocol_device_len(const struct device *dev)
 {
        return  4 + optional_strlen(dev->id) +
+               sizeof(dev->type) +
                4 + optional_strlen(dev->name) +
                4 + optional_strlen(dev->description) +
                4 + optional_strlen(dev->icon_file);
@@ -177,7 +195,9 @@ int pb_protocol_boot_option_len(const struct boot_option *opt)
                4 + optional_strlen(opt->icon_file) +
                4 + optional_strlen(opt->boot_image_file) +
                4 + optional_strlen(opt->initrd_file) +
-               4 + optional_strlen(opt->boot_args);
+               4 + optional_strlen(opt->dtb_file) +
+               4 + optional_strlen(opt->boot_args) +
+               sizeof(opt->is_default);
 }
 
 int pb_protocol_boot_len(const struct boot_command *boot)
@@ -185,6 +205,7 @@ int pb_protocol_boot_len(const struct boot_command *boot)
        return  4 + optional_strlen(boot->option_id) +
                4 + optional_strlen(boot->boot_image_file) +
                4 + optional_strlen(boot->initrd_file) +
+               4 + optional_strlen(boot->dtb_file) +
                4 + optional_strlen(boot->boot_args);
 }
 
@@ -196,12 +217,80 @@ int pb_protocol_boot_status_len(const struct boot_status *status)
                4;
 }
 
+int pb_protocol_system_info_len(const struct system_info *sysinfo)
+{
+       unsigned int len, i;
+
+       len =   4 + optional_strlen(sysinfo->type) +
+               4 + optional_strlen(sysinfo->identifier) +
+               4 + 4;
+
+       for (i = 0; i < sysinfo->n_interfaces; i++) {
+               struct interface_info *if_info = sysinfo->interfaces[i];
+               len +=  4 + if_info->hwaddr_size +
+                       4 + optional_strlen(if_info->name);
+       }
+
+       for (i = 0; i < sysinfo->n_blockdevs; i++) {
+               struct blockdev_info *bd_info = sysinfo->blockdevs[i];
+               len +=  4 + optional_strlen(bd_info->name) +
+                       4 + optional_strlen(bd_info->uuid) +
+                       4 + optional_strlen(bd_info->mountpoint);
+       }
+
+       return len;
+}
+
+static int pb_protocol_interface_config_len(struct interface_config *conf)
+{
+       unsigned int len;
+
+       len =   sizeof(conf->hwaddr) +
+               4 /* conf->ignore */;
+
+       if (conf->ignore)
+               return len;
+
+       len += 4 /* conf->method */;
+
+       if (conf->method == CONFIG_METHOD_STATIC) {
+               len += 4 + optional_strlen(conf->static_config.address);
+               len += 4 + optional_strlen(conf->static_config.gateway);
+       }
+
+       return len;
+}
+
+int pb_protocol_config_len(const struct config *config)
+{
+       unsigned int i, len;
+
+       len =   4 /* config->autoboot_enabled */ +
+               4 /* config->autoboot_timeout_sec */;
+
+       len += 4;
+       for (i = 0; i < config->network.n_interfaces; i++)
+               len += pb_protocol_interface_config_len(
+                               config->network.interfaces[i]);
+
+       len += 4;
+       for (i = 0; i < config->network.n_dns_servers; i++)
+               len += 4 + optional_strlen(config->network.dns_servers[i]);
+
+       len += 4;
+       len += config->n_boot_priorities * 4;
+
+       return len;
+}
+
 int pb_protocol_serialise_device(const struct device *dev,
                char *buf, int buf_len)
 {
        char *pos = buf;
 
        pos += pb_protocol_serialise_string(pos, dev->id);
+       *(enum device_type *)pos = dev->type;
+       pos += sizeof(enum device_type);
        pos += pb_protocol_serialise_string(pos, dev->name);
        pos += pb_protocol_serialise_string(pos, dev->description);
        pos += pb_protocol_serialise_string(pos, dev->icon_file);
@@ -224,8 +313,12 @@ int pb_protocol_serialise_boot_option(const struct boot_option *opt,
        pos += pb_protocol_serialise_string(pos, opt->icon_file);
        pos += pb_protocol_serialise_string(pos, opt->boot_image_file);
        pos += pb_protocol_serialise_string(pos, opt->initrd_file);
+       pos += pb_protocol_serialise_string(pos, opt->dtb_file);
        pos += pb_protocol_serialise_string(pos, opt->boot_args);
 
+       *(bool *)pos = opt->is_default;
+       pos += sizeof(bool);
+
        assert(pos <= buf + buf_len);
        (void)buf_len;
 
@@ -240,6 +333,7 @@ int pb_protocol_serialise_boot_command(const struct boot_command *boot,
        pos += pb_protocol_serialise_string(pos, boot->option_id);
        pos += pb_protocol_serialise_string(pos, boot->boot_image_file);
        pos += pb_protocol_serialise_string(pos, boot->initrd_file);
+       pos += pb_protocol_serialise_string(pos, boot->dtb_file);
        pos += pb_protocol_serialise_string(pos, boot->boot_args);
 
        assert(pos <= buf + buf_len);
@@ -268,6 +362,114 @@ int pb_protocol_serialise_boot_status(const struct boot_status *status,
        return 0;
 }
 
+int pb_protocol_serialise_system_info(const struct system_info *sysinfo,
+               char *buf, int buf_len)
+{
+       char *pos = buf;
+       unsigned int i;
+
+       pos += pb_protocol_serialise_string(pos, sysinfo->type);
+       pos += pb_protocol_serialise_string(pos, sysinfo->identifier);
+
+       *(uint32_t *)pos = __cpu_to_be32(sysinfo->n_interfaces);
+       pos += sizeof(uint32_t);
+
+       for (i = 0; i < sysinfo->n_interfaces; i++) {
+               struct interface_info *if_info = sysinfo->interfaces[i];
+
+               *(uint32_t *)pos = __cpu_to_be32(if_info->hwaddr_size);
+               pos += sizeof(uint32_t);
+
+               memcpy(pos, if_info->hwaddr, if_info->hwaddr_size);
+               pos += if_info->hwaddr_size;
+
+               pos += pb_protocol_serialise_string(pos, if_info->name);
+       }
+
+       *(uint32_t *)pos = __cpu_to_be32(sysinfo->n_blockdevs);
+       pos += sizeof(uint32_t);
+
+       for (i = 0; i < sysinfo->n_blockdevs; i++) {
+               struct blockdev_info *bd_info = sysinfo->blockdevs[i];
+
+               pos += pb_protocol_serialise_string(pos, bd_info->name);
+               pos += pb_protocol_serialise_string(pos, bd_info->uuid);
+               pos += pb_protocol_serialise_string(pos, bd_info->mountpoint);
+       }
+
+       assert(pos <= buf + buf_len);
+       (void)buf_len;
+
+       return 0;
+}
+
+static int pb_protocol_serialise_config_interface(char *buf,
+               struct interface_config *conf)
+{
+       char *pos = buf;
+
+       memcpy(pos, conf->hwaddr, sizeof(conf->hwaddr));
+       pos += sizeof(conf->hwaddr);
+
+       *(uint32_t *)pos = conf->ignore;
+       pos += 4;
+
+       if (conf->ignore)
+               return pos - buf;
+
+       *(uint32_t *)pos = __cpu_to_be32(conf->method);
+       pos += 4;
+
+       if (conf->method == CONFIG_METHOD_STATIC) {
+               pos += pb_protocol_serialise_string(pos,
+                               conf->static_config.address);
+               pos += pb_protocol_serialise_string(pos,
+                               conf->static_config.gateway);
+       }
+
+       return pos - buf;
+}
+
+int pb_protocol_serialise_config(const struct config *config,
+               char *buf, int buf_len)
+{
+       char *pos = buf;
+       unsigned int i;
+
+       *(uint32_t *)pos = config->autoboot_enabled;
+       pos += 4;
+
+       *(uint32_t *)pos = __cpu_to_be32(config->autoboot_timeout_sec);
+       pos += 4;
+
+       *(uint32_t *)pos = __cpu_to_be32(config->network.n_interfaces);
+       pos += 4;
+       for (i = 0; i < config->network.n_interfaces; i++) {
+               struct interface_config *iface =
+                       config->network.interfaces[i];
+               pos += pb_protocol_serialise_config_interface(pos, iface);
+       }
+
+       *(uint32_t *)pos = __cpu_to_be32(config->network.n_dns_servers);
+       pos += 4;
+       for (i = 0; i < config->network.n_dns_servers; i++) {
+               pos += pb_protocol_serialise_string(pos,
+                               config->network.dns_servers[i]);
+       }
+
+       *(uint32_t *)pos = __cpu_to_be32(config->n_boot_priorities);
+       pos += 4;
+       for (i = 0; i < config->n_boot_priorities; i++) {
+               *(uint32_t *)pos = __cpu_to_be32(config->boot_priorities[i].type);
+               pos += 4;
+       }
+
+       assert(pos <= buf + buf_len);
+       (void)buf_len;
+
+       return 0;
+}
+
 int pb_protocol_write_message(int fd, struct pb_protocol_message *message)
 {
        int total_len, rc;
@@ -372,6 +574,12 @@ int pb_protocol_deserialise_device(struct device *dev,
        if (read_string(dev, &pos, &len, &dev->id))
                goto out;
 
+       if (len < sizeof(enum device_type))
+               goto out;
+       dev->type = *(enum device_type *)(pos);
+       pos += sizeof(enum device_type);
+       len -= sizeof(enum device_type);
+
        if (read_string(dev, &pos, &len, &dev->name))
                goto out;
 
@@ -418,9 +626,16 @@ int pb_protocol_deserialise_boot_option(struct boot_option *opt,
        if (read_string(opt, &pos, &len, &opt->initrd_file))
                goto out;
 
+       if (read_string(opt, &pos, &len, &opt->dtb_file))
+               goto out;
+
        if (read_string(opt, &pos, &len, &opt->boot_args))
                goto out;
 
+       if (len < sizeof(bool))
+               goto out;
+       opt->is_default = *(bool *)(pos);
+
        rc = 0;
 
 out:
@@ -446,6 +661,9 @@ int pb_protocol_deserialise_boot_command(struct boot_command *cmd,
        if (read_string(cmd, &pos, &len, &cmd->initrd_file))
                goto out;
 
+       if (read_string(cmd, &pos, &len, &cmd->dtb_file))
+               goto out;
+
        if (read_string(cmd, &pos, &len, &cmd->boot_args))
                goto out;
 
@@ -504,3 +722,170 @@ int pb_protocol_deserialise_boot_status(struct boot_status *status,
 out:
        return rc;
 }
+
+int pb_protocol_deserialise_system_info(struct system_info *sysinfo,
+               const struct pb_protocol_message *message)
+{
+       unsigned int len, i;
+       const char *pos;
+       int rc = -1;
+
+       len = message->payload_len;
+       pos = message->payload;
+
+       /* type and identifier strings */
+       if (read_string(sysinfo, &pos, &len, &sysinfo->type))
+               goto out;
+
+       if (read_string(sysinfo, &pos, &len, &sysinfo->identifier))
+               goto out;
+
+       /* number of interfaces */
+       if (read_u32(&pos, &len, &sysinfo->n_interfaces))
+               goto out;
+
+       sysinfo->interfaces = talloc_array(sysinfo, struct interface_info *,
+                       sysinfo->n_interfaces);
+
+       for (i = 0; i < sysinfo->n_interfaces; i++) {
+               struct interface_info *if_info = talloc(sysinfo,
+                                                       struct interface_info);
+
+               if (read_u32(&pos, &len, &if_info->hwaddr_size))
+                       goto out;
+
+               if (len < if_info->hwaddr_size)
+                       goto out;
+
+               if_info->hwaddr = talloc_memdup(if_info, pos,
+                                               if_info->hwaddr_size);
+               pos += if_info->hwaddr_size;
+               len -= if_info->hwaddr_size;
+
+               if (read_string(if_info, &pos, &len, &if_info->name))
+                       goto out;
+
+               sysinfo->interfaces[i] = if_info;
+       }
+
+       /* number of interfaces */
+       if (read_u32(&pos, &len, &sysinfo->n_blockdevs))
+               goto out;
+
+       sysinfo->blockdevs = talloc_array(sysinfo, struct blockdev_info *,
+                       sysinfo->n_blockdevs);
+
+       for (i = 0; i < sysinfo->n_blockdevs; i++) {
+               struct blockdev_info *bd_info = talloc(sysinfo,
+                                                       struct blockdev_info);
+
+               if (read_string(bd_info, &pos, &len, &bd_info->name))
+                       goto out;
+
+               if (read_string(bd_info, &pos, &len, &bd_info->uuid))
+                       goto out;
+
+               if (read_string(bd_info, &pos, &len, &bd_info->mountpoint))
+                       goto out;
+
+               sysinfo->blockdevs[i] = bd_info;
+       }
+       rc = 0;
+
+out:
+       return rc;
+}
+
+static int pb_protocol_deserialise_config_interface(const char **buf,
+               unsigned int *len, struct interface_config *iface)
+{
+       unsigned int tmp;
+
+       if (*len < sizeof(iface->hwaddr))
+               return -1;
+
+       memcpy(iface->hwaddr, *buf, sizeof(iface->hwaddr));
+       *buf += sizeof(iface->hwaddr);
+       *len -= sizeof(iface->hwaddr);
+
+       if (read_u32(buf, len, &tmp))
+               return -1;
+       iface->ignore = !!tmp;
+
+       if (iface->ignore)
+               return 0;
+
+       if (read_u32(buf, len, &iface->method))
+               return -1;
+
+       if (iface->method == CONFIG_METHOD_STATIC) {
+               if (read_string(iface, buf, len, &iface->static_config.address))
+                       return -1;
+
+               if (read_string(iface, buf, len, &iface->static_config.gateway))
+                       return -1;
+       }
+
+       return 0;
+}
+
+int pb_protocol_deserialise_config(struct config *config,
+               const struct pb_protocol_message *message)
+{
+       unsigned int len, i, tmp;
+       const char *pos;
+       int rc = -1;
+
+       len = message->payload_len;
+       pos = message->payload;
+
+       if (read_u32(&pos, &len, &tmp))
+               goto out;
+       config->autoboot_enabled = !!tmp;
+
+       if (read_u32(&pos, &len, &config->autoboot_timeout_sec))
+               goto out;
+
+       if (read_u32(&pos, &len, &config->network.n_interfaces))
+               goto out;
+
+       config->network.interfaces = talloc_array(config,
+                       struct interface_config *, config->network.n_interfaces);
+
+       for (i = 0; i < config->network.n_interfaces; i++) {
+               struct interface_config *iface = talloc_zero(
+                               config->network.interfaces,
+                               struct interface_config);
+               if (pb_protocol_deserialise_config_interface(&pos, &len, iface))
+                       goto out;
+               config->network.interfaces[i] = iface;
+       }
+
+       if (read_u32(&pos, &len, &config->network.n_dns_servers))
+               goto out;
+       config->network.dns_servers = talloc_array(config, const char *,
+                       config->network.n_dns_servers);
+
+       for (i = 0; i < config->network.n_dns_servers; i++) {
+               char *tmp;
+               if (read_string(config->network.dns_servers, &pos, &len, &tmp))
+                       goto out;
+               config->network.dns_servers[i] = tmp;
+       }
+
+       if (read_u32(&pos, &len, &config->n_boot_priorities))
+               goto out;
+       config->boot_priorities = talloc_array(config, struct boot_priority,
+                       config->n_boot_priorities);
+
+       for (i = 0; i < config->n_boot_priorities; i++) {
+               if (read_u32(&pos, &len, &tmp))
+                       goto out;
+               config->boot_priorities[i].type = tmp;
+       }
+
+       rc = 0;
+
+out:
+       return rc;
+}