protocol: Add block device information to system info
[petitboot] / lib / pb-protocol / pb-protocol.c
index fdf24471377160e9a3c51abb87c4197e4e034e1c..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
  *    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
  *  payload:
  *   4-byte len, id
+ *
+ * action = 0x3: boot
+ *  payload:
+ *   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
+ *
  */
 
 void pb_protocol_dump_device(const struct device *dev, const char *text,
@@ -58,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);
        }
 }
@@ -128,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)
 {
@@ -153,60 +178,290 @@ static int optional_strlen(const char *str)
 
 int pb_protocol_device_len(const struct device *dev)
 {
-       struct boot_option *opt;
-       int len;
-
-       len =   4 + optional_strlen(dev->id) +
+       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) +
+               4 + optional_strlen(dev->icon_file);
+}
+
+int pb_protocol_boot_option_len(const struct boot_option *opt)
+{
+
+       return  4 + optional_strlen(opt->device_id) +
+               4 + optional_strlen(opt->id) +
+               4 + optional_strlen(opt->name) +
+               4 + optional_strlen(opt->description) +
+               4 + optional_strlen(opt->icon_file) +
+               4 + optional_strlen(opt->boot_image_file) +
+               4 + optional_strlen(opt->initrd_file) +
+               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)
+{
+       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;
+}
 
-       list_for_each_entry(&dev->boot_options, opt, list) {
-               len +=  4 + optional_strlen(opt->id) +
-                       4 + optional_strlen(opt->name) +
-                       4 + optional_strlen(opt->description) +
-                       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);
+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;
 }
 
-int pb_protocol_serialise_device(const struct device *dev, char *buf, int buf_len)
+static int pb_protocol_interface_config_len(struct interface_config *conf)
 {
-       struct boot_option *opt;
-       uint32_t n;
-       char *pos;
+       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 */;
 
-       pos = buf;
+       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;
 
-       /* construct payload into buffer */
        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);
 
-       /* write option count */
-       n = 0;
+       assert(pos <= buf + buf_len);
+       (void)buf_len;
+
+       return 0;
+}
+
+int pb_protocol_serialise_boot_option(const struct boot_option *opt,
+               char *buf, int buf_len)
+{
+       char *pos = buf;
+
+       pos += pb_protocol_serialise_string(pos, opt->device_id);
+       pos += pb_protocol_serialise_string(pos, opt->id);
+       pos += pb_protocol_serialise_string(pos, opt->name);
+       pos += pb_protocol_serialise_string(pos, opt->description);
+       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;
+
+       return 0;
+}
+
+int pb_protocol_serialise_boot_command(const struct boot_command *boot,
+               char *buf, int buf_len)
+{
+       char *pos = buf;
+
+       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);
+       (void)buf_len;
+
+       return 0;
+}
 
-       list_for_each_entry(&dev->boot_options, opt, list)
-               n++;
+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(n);
+       *(uint32_t *)pos = __cpu_to_be32(status->type);
        pos += sizeof(uint32_t);
 
-       /* write each option */
-       list_for_each_entry(&dev->boot_options, opt, list) {
-               pos += pb_protocol_serialise_string(pos, opt->id);
-               pos += pb_protocol_serialise_string(pos, opt->name);
-               pos += pb_protocol_serialise_string(pos, opt->description);
-               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->boot_args);
+       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_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);
@@ -306,69 +561,331 @@ struct pb_protocol_message *pb_protocol_read_message(void *ctx, int fd)
 }
 
 
-struct device *pb_protocol_deserialise_device(void *ctx,
+int pb_protocol_deserialise_device(struct device *dev,
                const struct pb_protocol_message *message)
 {
-       struct device *dev;
-       const char *pos;
-       int i, n_options;
        unsigned int len;
+       const char *pos;
+       int rc = -1;
 
        len = message->payload_len;
        pos = message->payload;
 
-       dev = talloc(ctx, struct device);
-
        if (read_string(dev, &pos, &len, &dev->id))
-               goto out_err;
+               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_err;
+               goto out;
 
        if (read_string(dev, &pos, &len, &dev->description))
-               goto out_err;
+               goto out;
 
        if (read_string(dev, &pos, &len, &dev->icon_file))
-               goto out_err;
+               goto out;
+
+       rc = 0;
+
+out:
+       return rc;
+}
+
+int pb_protocol_deserialise_boot_option(struct boot_option *opt,
+               const struct pb_protocol_message *message)
+{
+       unsigned int len;
+       const char *pos;
+       int rc = -1;
+
+       len = message->payload_len;
+       pos = message->payload;
+
+       if (read_string(opt, &pos, &len, &opt->device_id))
+               goto out;
+
+       if (read_string(opt, &pos, &len, &opt->id))
+               goto out;
+
+       if (read_string(opt, &pos, &len, &opt->name))
+               goto out;
+
+       if (read_string(opt, &pos, &len, &opt->description))
+               goto out;
+
+       if (read_string(opt, &pos, &len, &opt->icon_file))
+               goto out;
+
+       if (read_string(opt, &pos, &len, &opt->boot_image_file))
+               goto out;
+
+       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:
+       return rc;
+}
+
+int pb_protocol_deserialise_boot_command(struct boot_command *cmd,
+               const struct pb_protocol_message *message)
+{
+       unsigned int len;
+       const char *pos;
+       int rc = -1;
+
+       len = message->payload_len;
+       pos = message->payload;
+
+       if (read_string(cmd, &pos, &len, &cmd->option_id))
+               goto out;
+
+       if (read_string(cmd, &pos, &len, &cmd->boot_image_file))
+               goto out;
+
+       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;
+
+       rc = 0;
+
+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;
+       }
 
-       n_options = __be32_to_cpu(*(uint32_t *)pos);
        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;
+
+       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);
 
-       dev->n_options = n_options;
-
-       list_init(&dev->boot_options);
-
-       for (i = 0; i < n_options; i++) {
-               struct boot_option *opt;
-
-               opt = talloc(dev, struct boot_option);
-
-               if (read_string(opt, &pos, &len, &opt->id))
-                       goto out_err;
-               if (read_string(opt, &pos, &len, &opt->name))
-                       goto out_err;
-               if (read_string(opt, &pos, &len,
-                                       &opt->description))
-                       goto out_err;
-               if (read_string(opt, &pos, &len,
-                                       &opt->icon_file))
-                       goto out_err;
-               if (read_string(opt, &pos, &len,
-                                       &opt->boot_image_file))
-                       goto out_err;
-               if (read_string(opt, &pos, &len,
-                                       &opt->initrd_file))
-                       goto out_err;
-               if (read_string(opt, &pos, &len,
-                                       &opt->boot_args))
-                       goto out_err;
-
-               list_add(&dev->boot_options, &opt->list);
+       for (i = 0; i < config->n_boot_priorities; i++) {
+               if (read_u32(&pos, &len, &tmp))
+                       goto out;
+               config->boot_priorities[i].type = tmp;
        }
 
-       return dev;
+       rc = 0;
 
-out_err:
-       talloc_free(dev);
-       return NULL;
+out:
+       return rc;
 }