ui/ncurses: Keep track of the default boot option

[petitboot] / lib / pb-protocol / pb-protocol.c

diff --git a/lib/pb-protocol/pb-protocol.c b/lib/pb-protocol/pb-protocol.c
index 41707da09ab0d7345c8d0a0a2d2f9d1b48f43517..d8771fcb9493296be9b879c1f841d4aa681a6273 100644 (file)
--- a/lib/pb-protocol/pb-protocol.c
+++ b/lib/pb-protocol/pb-protocol.c
@@ -204,6 +204,7 @@ int pb_protocol_boot_option_len(const struct boot_option *opt)
                4 + optional_strlen(opt->boot_args) +
                4 + optional_strlen(opt->args_sig_file) +
                sizeof(opt->is_default) +
+               sizeof(opt->is_autoboot_default) +
                sizeof(opt->type);
 }
 
@@ -223,7 +224,7 @@ int pb_protocol_boot_status_len(const struct status *status)
        return  4 +     /* type */
                4 + optional_strlen(status->message) +
                4 +     /* backlog */
-               4;
+               4;      /* boot_active */
 }
 
 int pb_protocol_system_info_len(const struct system_info *sysinfo)
@@ -379,6 +380,25 @@ int pb_protocol_temp_autoboot_len(const struct autoboot_option *opt)
        return len;
 }
 
+int pb_protocol_authenticate_len(struct auth_message *msg)
+{
+       switch (msg->op) {
+       case AUTH_MSG_REQUEST:
+               /* enum + password + length */
+               return 4 + 4 + optional_strlen(msg->password);
+       case AUTH_MSG_RESPONSE:
+               /* enum + bool */
+               return 4 + 4;
+       case AUTH_MSG_SET:
+               /* enum + password + password */
+               return 4 + 4 + optional_strlen(msg->set_password.password) +
+                       4 + optional_strlen(msg->set_password.new_password);
+       default:
+               pb_log("%s: invalid input\n", __func__);
+               return 0;
+       }
+}
+
 int pb_protocol_serialise_device(const struct device *dev,
                char *buf, int buf_len)
 {
@@ -415,6 +435,8 @@ int pb_protocol_serialise_boot_option(const struct boot_option *opt,
 
        *(bool *)pos = opt->is_default;
        pos += sizeof(bool);
+       *(bool *)pos = opt->is_autoboot_default;
+       pos += sizeof(bool);
 
        *(uint32_t *)pos = __cpu_to_be32(opt->type);
        pos += 4;
@@ -457,6 +479,9 @@ int pb_protocol_serialise_boot_status(const struct status *status,
        *(bool *)pos = __cpu_to_be32(status->backlog);
        pos += sizeof(bool);
 
+       *(bool *)pos = __cpu_to_be32(status->boot_active);
+       pos += sizeof(bool);
+
        assert(pos <= buf + buf_len);
        (void)buf_len;
 
@@ -700,6 +725,39 @@ int pb_protocol_serialise_temp_autoboot(const struct autoboot_option *opt,
        return 0;
 }
 
+int pb_protocol_serialise_authenticate(struct auth_message *msg,
+               char *buf, int buf_len)
+{
+       char *pos = buf;
+
+       *(enum auth_msg_type *)pos = msg->op;
+       pos += sizeof(enum auth_msg_type);
+
+       switch(msg->op) {
+       case AUTH_MSG_REQUEST:
+               pos += pb_protocol_serialise_string(pos, msg->password);
+               break;
+       case AUTH_MSG_RESPONSE:
+               *(bool *)pos = msg->authenticated;
+               pos += sizeof(bool);
+               break;
+       case AUTH_MSG_SET:
+               pos += pb_protocol_serialise_string(pos,
+                               msg->set_password.password);
+               pos += pb_protocol_serialise_string(pos,
+                               msg->set_password.new_password);
+               break;
+       default:
+               pb_log("%s: invalid msg\n", __func__);
+               return -1;
+       };
+
+       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;
@@ -725,7 +783,7 @@ int pb_protocol_write_message(int fd, struct pb_protocol_message *message)
        if (!total_len)
                return 0;
 
-       pb_log("%s: failed: %s\n", __func__, strerror(errno));
+       pb_log_fn("failed: %s\n", strerror(errno));
        return -1;
 }
 
@@ -735,7 +793,7 @@ struct pb_protocol_message *pb_protocol_create_message(void *ctx,
        struct pb_protocol_message *message;
 
        if (payload_len > PB_PROTOCOL_MAX_PAYLOAD_SIZE) {
-               pb_log("%s: payload too big %u/%u\n", __func__, payload_len,
+               pb_log_fn("payload too big %u/%u\n", payload_len,
                        PB_PROTOCOL_MAX_PAYLOAD_SIZE);
                return NULL;
        }
@@ -766,7 +824,7 @@ struct pb_protocol_message *pb_protocol_read_message(void *ctx, int fd)
        m.action = __be32_to_cpu(m.action);
 
        if (m.payload_len > PB_PROTOCOL_MAX_PAYLOAD_SIZE) {
-               pb_log("%s: payload too big %u/%u\n", __func__, m.payload_len,
+               pb_log_fn("payload too big %u/%u\n", m.payload_len,
                        PB_PROTOCOL_MAX_PAYLOAD_SIZE);
                return NULL;
        }
@@ -779,7 +837,7 @@ struct pb_protocol_message *pb_protocol_read_message(void *ctx, int fd)
 
                if (rc <= 0) {
                        talloc_free(message);
-                       pb_log("%s: failed (%u): %s\n", __func__, len,
+                       pb_log_fn("failed (%u): %s\n", len,
                                strerror(errno));
                        return NULL;
                }
@@ -870,6 +928,9 @@ int pb_protocol_deserialise_boot_option(struct boot_option *opt,
        opt->is_default = *(bool *)(pos);
        pos += sizeof(bool);
        len -= sizeof(bool);
+       opt->is_autoboot_default = *(bool *)(pos);
+       pos += sizeof(bool);
+       len -= sizeof(bool);
 
        if (read_u32(&pos, &len, &opt->type))
                return -1;
@@ -952,6 +1013,10 @@ int pb_protocol_deserialise_boot_status(struct status *status,
        status->backlog = *(bool *)pos;
        pos += sizeof(status->backlog);
 
+       /* boot_active */
+       status->boot_active = *(bool *)pos;
+       pos += sizeof(status->boot_active);
+
        rc = 0;
 
 out:
@@ -1339,3 +1404,39 @@ int pb_protocol_deserialise_temp_autoboot(struct autoboot_option *opt,
 out:
        return rc;
 }
+
+int pb_protocol_deserialise_authenticate(struct auth_message *msg,
+               const struct pb_protocol_message *message)
+{
+       unsigned int len;
+       const char *pos;
+
+       len = message->payload_len;
+       pos = message->payload;
+
+       msg->op = *(enum auth_msg_type *)pos;
+       pos += sizeof(enum auth_msg_type);
+
+       switch (msg->op) {
+       case AUTH_MSG_REQUEST:
+               if (read_string(msg, &pos, &len, &msg->password))
+                       return -1;
+               break;
+       case AUTH_MSG_RESPONSE:
+               msg->authenticated = *(bool *)pos;
+               pos += sizeof(bool);
+               break;
+       case AUTH_MSG_SET:
+               if (read_string(msg, &pos, &len, &msg->set_password.password))
+                       return -1;
+               if (read_string(msg, &pos, &len,
+                                       &msg->set_password.new_password))
+                       return -1;
+               break;
+       default:
+               pb_log("%s: unable to parse\n", __func__);
+               return -1;
+       }
+
+       return 0;
+}