X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=lib%2Fpb-protocol%2Fpb-protocol.c;h=e99ce86292c90baf111efd84865e7b8aa48a5197;hp=ded35eb5a1f5888b01374ac028fe9af2d68f2d0b;hb=d974c3c39237c8e94bb3a51d3511d18dea01043e;hpb=bd06734362bb727b09b943688d9b69aa0a84590d

diff --git a/lib/pb-protocol/pb-protocol.c b/lib/pb-protocol/pb-protocol.c
index ded35eb..e99ce86 100644
--- a/lib/pb-protocol/pb-protocol.c
+++ b/lib/pb-protocol/pb-protocol.c
@@ -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,15 +205,123 @@ 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);
 }
 
+int pb_protocol_boot_status_len(const struct boot_status *status)
+{
+	return  4 +
+		4 + optional_strlen(status->message) +
+		4 + optional_strlen(status->detail) +
+		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;
+
+	len +=	4;
+	for (i = 0; i < sysinfo->n_current; i++)
+		len += 4 + optional_strlen(sysinfo->platform_current[i]);
+	len +=	4;
+	for (i = 0; i < sysinfo->n_other; i++)
+		len += 4 + optional_strlen(sysinfo->platform_other[i]);
+
+	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) +
+			sizeof(if_info->link);
+	}
+
+	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);
+	}
+
+	/* BMC MAC */
+	len += HWADDR_SIZE;
+
+	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);
+		len += 4 + optional_strlen(conf->static_config.url);
+	}
+
+	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 */ +
+		4 /* config->safe_mode */;
+
+	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;
+	for (i = 0; i < config->n_autoboot_opts; i++) {
+		if (config->autoboot_opts[i].boot_type == BOOT_DEVICE_TYPE)
+			len += 4 + 4;
+		else
+			len += 4 + 4 +
+				optional_strlen(config->autoboot_opts[i].uuid);
+	}
+
+	len += 4 + 4; /* ipmi_bootdev, ipmi_bootdev_persistent */
+
+	len += 4; /* allow_writes */
+
+	len += 4 + optional_strlen(config->lang);
+
+	return len;
+}
+
+int pb_protocol_url_len(const char *url)
+{
+	/* url + length field */
+	return 4 + optional_strlen(url);
+}
+
 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);
@@ -216,8 +344,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;
 
@@ -232,6 +364,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);
@@ -240,6 +373,189 @@ int pb_protocol_serialise_boot_command(const struct boot_command *boot,
 	return 0;
 }
 
+int pb_protocol_serialise_boot_status(const struct boot_status *status,
+		char *buf, int buf_len)
+{
+	char *pos = buf;
+
+	*(uint32_t *)pos = __cpu_to_be32(status->type);
+	pos += sizeof(uint32_t);
+
+	pos += pb_protocol_serialise_string(pos, status->message);
+	pos += pb_protocol_serialise_string(pos, status->detail);
+
+	*(uint32_t *)pos = __cpu_to_be32(status->type);
+	pos += sizeof(uint32_t);
+
+	assert(pos <= buf + buf_len);
+	(void)buf_len;
+
+	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_current);
+	pos += sizeof(uint32_t);
+	for (i = 0; i < sysinfo->n_current; i++)
+		pos += pb_protocol_serialise_string(pos, sysinfo->platform_current[i]);
+
+	*(uint32_t *)pos = __cpu_to_be32(sysinfo->n_other);
+	pos += sizeof(uint32_t);
+	for (i = 0; i < sysinfo->n_other; i++)
+		pos += pb_protocol_serialise_string(pos, sysinfo->platform_other[i]);
+
+	*(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);
+
+		*(bool *)pos = if_info->link;
+		pos += sizeof(bool);
+	}
+
+	*(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);
+	}
+
+	if (sysinfo->bmc_mac)
+		memcpy(pos, sysinfo->bmc_mac, HWADDR_SIZE);
+	else
+		memset(pos, 0, HWADDR_SIZE);
+	pos += HWADDR_SIZE;
+
+	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);
+		pos += pb_protocol_serialise_string(pos,
+				conf->static_config.url);
+	}
+
+	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 = config->safe_mode;
+	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_autoboot_opts);
+	pos += 4;
+	for (i = 0; i < config->n_autoboot_opts; i++) {
+		*(uint32_t *)pos =
+			__cpu_to_be32(config->autoboot_opts[i].boot_type);
+		pos += 4;
+		if (config->autoboot_opts[i].boot_type == BOOT_DEVICE_TYPE) {
+			*(uint32_t *)pos =
+				__cpu_to_be32(config->autoboot_opts[i].type);
+			pos += 4;
+		} else {
+			pos += pb_protocol_serialise_string(pos,
+						config->autoboot_opts[i].uuid);
+		}
+	}
+
+	*(uint32_t *)pos = __cpu_to_be32(config->ipmi_bootdev);
+	pos += 4;
+	*(uint32_t *)pos = config->ipmi_bootdev_persistent;
+	pos += 4;
+
+	*(uint32_t *)pos = config->allow_writes;
+	pos += 4;
+
+	pos += pb_protocol_serialise_string(pos, config->lang);
+
+	assert(pos <= buf + buf_len);
+	(void)buf_len;
+
+	return 0;
+}
+
+int pb_protocol_serialise_url(const char *url, char *buf, int buf_len)
+{
+	char *pos = buf;
+
+	pos += pb_protocol_serialise_string(pos, url);
+
+	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;
@@ -344,6 +660,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;
 
@@ -390,9 +712,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:
@@ -418,6 +747,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;
 
@@ -426,3 +758,286 @@ int pb_protocol_deserialise_boot_command(struct boot_command *cmd,
 out:
 	return rc;
 }
+
+int pb_protocol_deserialise_boot_status(struct boot_status *status,
+		const struct pb_protocol_message *message)
+{
+	unsigned int len;
+	const char *pos;
+	int rc = -1;
+
+	len = message->payload_len;
+	pos = message->payload;
+
+	/* first up, the type enum... */
+	if (len < sizeof(uint32_t))
+		goto out;
+
+	status->type = __be32_to_cpu(*(uint32_t *)(pos));
+
+	switch (status->type) {
+	case BOOT_STATUS_ERROR:
+	case BOOT_STATUS_INFO:
+		break;
+	default:
+		goto out;
+	}
+
+	pos += sizeof(uint32_t);
+	len -= sizeof(uint32_t);
+
+	/* message and detail strings */
+	if (read_string(status, &pos, &len, &status->message))
+		goto out;
+
+	if (read_string(status, &pos, &len, &status->detail))
+		goto out;
+
+	/* and finally, progress */
+	if (len < sizeof(uint32_t))
+		goto out;
+
+	status->progress = __be32_to_cpu(*(uint32_t *)(pos));
+
+	/* clamp to 100% */
+	if (status->progress > 100)
+		status->progress = 100;
+
+	rc = 0;
+
+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;
+	char *tmp;
+
+	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;
+
+	/* versions strings for openpower platforms */
+	if (read_u32(&pos, &len, &sysinfo->n_current))
+		goto out;
+	sysinfo->platform_current = talloc_array(sysinfo, char *,
+						sysinfo->n_current);
+	for (i = 0; i < sysinfo->n_current; i++) {
+		if (read_string(sysinfo, &pos, &len, &tmp))
+			goto out;
+		sysinfo->platform_current[i] = talloc_strdup(sysinfo, tmp);
+	}
+
+	if (read_u32(&pos, &len, &sysinfo->n_other))
+		goto out;
+	sysinfo->platform_other = talloc_array(sysinfo, char *,
+						sysinfo->n_other);
+	for (i = 0; i < sysinfo->n_other; i++) {
+		if (read_string(sysinfo, &pos, &len, &tmp))
+			goto out;
+		sysinfo->platform_other[i] = talloc_strdup(sysinfo, tmp);
+	}
+
+	/* 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;
+
+		if_info->link = *(bool *)pos;
+		pos += sizeof(if_info->link);
+
+		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;
+	}
+
+	for (i = 0; i < HWADDR_SIZE; i++) {
+		if (pos[i] != 0) {
+			sysinfo->bmc_mac = talloc_memdup(sysinfo, pos, HWADDR_SIZE);
+			break;
+		}
+	}
+
+	pos += HWADDR_SIZE;
+	len -= HWADDR_SIZE;
+
+	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;
+
+		if (read_string(iface, buf, len, &iface->static_config.url))
+			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;
+	char *str;
+
+	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, &tmp))
+		goto out;
+	config->safe_mode = !!tmp;
+
+	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++) {
+		if (read_string(config->network.dns_servers, &pos, &len, &str))
+			goto out;
+		config->network.dns_servers[i] = str;
+	}
+
+	if (read_u32(&pos, &len, &config->n_autoboot_opts))
+		goto out;
+	config->autoboot_opts = talloc_array(config, struct autoboot_option,
+			config->n_autoboot_opts);
+
+	for (i = 0; i < config->n_autoboot_opts; i++) {
+		if (read_u32(&pos, &len, &tmp))
+			goto out;
+		config->autoboot_opts[i].boot_type = (int)tmp;
+		if (config->autoboot_opts[i].boot_type == BOOT_DEVICE_TYPE) {
+			if (read_u32(&pos, &len, &tmp))
+				goto out;
+			config->autoboot_opts[i].type = tmp;
+		} else {
+			if (read_string(config, &pos, &len, &str))
+				goto out;
+			config->autoboot_opts[i].uuid = str;
+		}
+	}
+
+	if (read_u32(&pos, &len, &config->ipmi_bootdev))
+		goto out;
+	if (read_u32(&pos, &len, &tmp))
+		goto out;
+	config->ipmi_bootdev_persistent = !!tmp;
+
+	if (read_u32(&pos, &len, &tmp))
+		goto out;
+	config->allow_writes = !!tmp;
+
+	if (read_string(config, &pos, &len, &str))
+		goto out;
+
+	config->lang = str;
+
+	rc = 0;
+
+out:
+	return rc;
+}