git.ozlabs.org Git - petitboot/blob - lib/pb-protocol/pb-protocol.c

   1
   2 #include <assert.h>
   3 #include <errno.h>
   4 #include <string.h>
   5 #include <stdbool.h>
   6 #include <stdint.h>
   7 #include <asm/byteorder.h>
   8
   9 #include <talloc/talloc.h>
  10 #include <list/list.h>
  11 #include <log/log.h>
  12
  13 #include "pb-protocol.h"
  14
  15
  16 /* Message format:
  17  *
  18  * 4-byte action, determines the remaining message content
  19  * 4-byte total payload len
  20  *   - not including action and payload len header
  21  *
  22  * action = 0x1: device add message
  23  *  payload:
  24  *   4-byte len, id
  25  *   4-byte len, name
  26  *   4-byte len, description
  27  *   4-byte len, icon_file
  28  *
  29  *   4-byte option count
  30  *   for each option:
  31  *    4-byte len, id
  32  *    4-byte len, name
  33  *    4-byte len, description
  34  *    4-byte len, icon_file
  35  *    4-byte len, boot_image_file
  36  *    4-byte len, initrd_file
  37  *    4-byte len, boot_args
  38  *
  39  * action = 0x2: device remove message
  40  *  payload:
  41  *   4-byte len, id
  42  *
  43  * action = 0x3: boot
  44  *  payload:
  45  *   4-byte len, boot option id
  46  *   4-byte len, boot_image_file
  47  *   4-byte len, initrd_file
  48  *   4-byte len, boot_args
  49  *
  50  */
  51
  52 void pb_protocol_dump_device(const struct device *dev, const char *text,
  53         FILE *stream)
  54 {
  55         struct boot_option *opt;
  56
  57         fprintf(stream, "%snew dev:\n", text);
  58         fprintf(stream, "%s\tid:   %s\n", text, dev->id);
  59         fprintf(stream, "%s\tname: %s\n", text, dev->name);
  60         fprintf(stream, "%s\tdesc: %s\n", text, dev->description);
  61         fprintf(stream, "%s\ticon: %s\n", text, dev->icon_file);
  62         fprintf(stream, "%s\tboot options:\n", text);
  63         list_for_each_entry(&dev->boot_options, opt, list) {
  64                 fprintf(stream, "%s\t\tid:   %s\n", text, opt->id);
  65                 fprintf(stream, "%s\t\tname: %s\n", text, opt->name);
  66                 fprintf(stream, "%s\t\tdesc: %s\n", text, opt->description);
  67                 fprintf(stream, "%s\t\ticon: %s\n", text, opt->icon_file);
  68                 fprintf(stream, "%s\t\tboot: %s\n", text, opt->boot_image_file);
  69                 fprintf(stream, "%s\t\tinit: %s\n", text, opt->initrd_file);
  70                 fprintf(stream, "%s\t\targs: %s\n", text, opt->boot_args);
  71         }
  72 }
  73
  74 int pb_protocol_device_cmp(const struct device *a, const struct device *b)
  75 {
  76         return !strcmp(a->id, b->id);
  77 }
  78
  79 int pb_protocol_boot_option_cmp(const struct boot_option *a,
  80         const struct boot_option *b)
  81 {
  82         return !strcmp(a->id, b->id);
  83 }
  84
  85 /* Write a string into the buffer, starting at pos.
  86  *
  87  * Returns the total length used for the write, including length header.
  88  */
  89 int pb_protocol_serialise_string(char *pos, const char *str)
  90 {
  91         int len = 0;
  92
  93         if (str)
  94                 len = strlen(str);
  95
  96         *(uint32_t *)pos = __cpu_to_be32(len);
  97         pos += sizeof(uint32_t);
  98
  99         memcpy(pos, str, len);
 100
 101         return len + sizeof(uint32_t);
 102 }
 103
 104 /* Read a string from a buffer, allocating the new string as necessary.
 105  *
 106  * @param[in] ctx       The talloc context to base the allocation on
 107  * @param[in,out] pos   Where to start reading
 108  * @param[in,out] len   The amount of data remaining in the buffer
 109  * @param[out] str      Pointer to resuling string
 110  * @return              zero on success, non-zero on failure
 111  */
 112 static int read_string(void *ctx, const char **pos, unsigned int *len,
 113         char **str)
 114 {
 115         uint32_t str_len, read_len;
 116
 117         if (*len < sizeof(uint32_t))
 118                 return -1;
 119
 120         str_len = __be32_to_cpu(*(uint32_t *)(*pos));
 121         read_len = sizeof(uint32_t);
 122
 123         if (read_len + str_len > *len)
 124                 return -1;
 125
 126         if (str_len == 0)
 127                 *str = NULL;
 128         else
 129                 *str = talloc_strndup(ctx, *pos + read_len, str_len);
 130
 131         read_len += str_len;
 132
 133         /* all ok, update the caller's pointers */
 134         *pos += read_len;
 135         *len -= read_len;
 136
 137         return 0;
 138 }
 139
 140 char *pb_protocol_deserialise_string(void *ctx,
 141                 const struct pb_protocol_message *message)
 142 {
 143         const char *buf;
 144         char *str;
 145         unsigned int len;
 146
 147         len = message->payload_len;
 148         buf = message->payload;
 149
 150         if (read_string(ctx, &buf, &len, &str))
 151                 return NULL;
 152
 153         return str;
 154 }
 155
 156 static int optional_strlen(const char *str)
 157 {
 158         if (!str)
 159                 return 0;
 160         return strlen(str);
 161 }
 162
 163 int pb_protocol_device_len(const struct device *dev)
 164 {
 165         return  4 + optional_strlen(dev->id) +
 166                 4 + optional_strlen(dev->name) +
 167                 4 + optional_strlen(dev->description) +
 168                 4 + optional_strlen(dev->icon_file);
 169 }
 170
 171 int pb_protocol_boot_option_len(const struct boot_option *opt)
 172 {
 173
 174         return  4 + optional_strlen(opt->device_id) +
 175                 4 + optional_strlen(opt->id) +
 176                 4 + optional_strlen(opt->name) +
 177                 4 + optional_strlen(opt->description) +
 178                 4 + optional_strlen(opt->icon_file) +
 179                 4 + optional_strlen(opt->boot_image_file) +
 180                 4 + optional_strlen(opt->initrd_file) +
 181                 4 + optional_strlen(opt->boot_args) +
 182                 sizeof(opt->is_default);
 183 }
 184
 185 int pb_protocol_boot_len(const struct boot_command *boot)
 186 {
 187         return  4 + optional_strlen(boot->option_id) +
 188                 4 + optional_strlen(boot->boot_image_file) +
 189                 4 + optional_strlen(boot->initrd_file) +
 190                 4 + optional_strlen(boot->boot_args);
 191 }
 192
 193 int pb_protocol_boot_status_len(const struct boot_status *status)
 194 {
 195         return  4 +
 196                 4 + optional_strlen(status->message) +
 197                 4 + optional_strlen(status->detail) +
 198                 4;
 199 }
 200
 201 int pb_protocol_serialise_device(const struct device *dev,
 202                 char *buf, int buf_len)
 203 {
 204         char *pos = buf;
 205
 206         pos += pb_protocol_serialise_string(pos, dev->id);
 207         pos += pb_protocol_serialise_string(pos, dev->name);
 208         pos += pb_protocol_serialise_string(pos, dev->description);
 209         pos += pb_protocol_serialise_string(pos, dev->icon_file);
 210
 211         assert(pos <= buf + buf_len);
 212         (void)buf_len;
 213
 214         return 0;
 215 }
 216
 217 int pb_protocol_serialise_boot_option(const struct boot_option *opt,
 218                 char *buf, int buf_len)
 219 {
 220         char *pos = buf;
 221
 222         pos += pb_protocol_serialise_string(pos, opt->device_id);
 223         pos += pb_protocol_serialise_string(pos, opt->id);
 224         pos += pb_protocol_serialise_string(pos, opt->name);
 225         pos += pb_protocol_serialise_string(pos, opt->description);
 226         pos += pb_protocol_serialise_string(pos, opt->icon_file);
 227         pos += pb_protocol_serialise_string(pos, opt->boot_image_file);
 228         pos += pb_protocol_serialise_string(pos, opt->initrd_file);
 229         pos += pb_protocol_serialise_string(pos, opt->boot_args);
 230
 231         *(bool *)pos = opt->is_default;
 232         pos += sizeof(bool);
 233
 234         assert(pos <= buf + buf_len);
 235         (void)buf_len;
 236
 237         return 0;
 238 }
 239
 240 int pb_protocol_serialise_boot_command(const struct boot_command *boot,
 241                 char *buf, int buf_len)
 242 {
 243         char *pos = buf;
 244
 245         pos += pb_protocol_serialise_string(pos, boot->option_id);
 246         pos += pb_protocol_serialise_string(pos, boot->boot_image_file);
 247         pos += pb_protocol_serialise_string(pos, boot->initrd_file);
 248         pos += pb_protocol_serialise_string(pos, boot->boot_args);
 249
 250         assert(pos <= buf + buf_len);
 251         (void)buf_len;
 252
 253         return 0;
 254 }
 255
 256 int pb_protocol_serialise_boot_status(const struct boot_status *status,
 257                 char *buf, int buf_len)
 258 {
 259         char *pos = buf;
 260
 261         *(uint32_t *)pos = __cpu_to_be32(status->type);
 262         pos += sizeof(uint32_t);
 263
 264         pos += pb_protocol_serialise_string(pos, status->message);
 265         pos += pb_protocol_serialise_string(pos, status->detail);
 266
 267         *(uint32_t *)pos = __cpu_to_be32(status->type);
 268         pos += sizeof(uint32_t);
 269
 270         assert(pos <= buf + buf_len);
 271         (void)buf_len;
 272
 273         return 0;
 274 }
 275
 276 int pb_protocol_write_message(int fd, struct pb_protocol_message *message)
 277 {
 278         int total_len, rc;
 279         char *pos;
 280
 281         total_len = sizeof(*message) + message->payload_len;
 282
 283         message->payload_len = __cpu_to_be32(message->payload_len);
 284         message->action = __cpu_to_be32(message->action);
 285
 286         for (pos = (void *)message; total_len;) {
 287                 rc = write(fd, pos, total_len);
 288
 289                 if (rc <= 0)
 290                         break;
 291
 292                 total_len -= rc;
 293                 pos += rc;
 294         }
 295
 296         talloc_free(message);
 297
 298         if (!total_len)
 299                 return 0;
 300
 301         pb_log("%s: failed: %s\n", __func__, strerror(errno));
 302         return -1;
 303 }
 304
 305 struct pb_protocol_message *pb_protocol_create_message(void *ctx,
 306                 enum pb_protocol_action action, int payload_len)
 307 {
 308         struct pb_protocol_message *message;
 309
 310         if (payload_len > PB_PROTOCOL_MAX_PAYLOAD_SIZE) {
 311                 pb_log("%s: payload too big %u/%u\n", __func__, payload_len,
 312                         PB_PROTOCOL_MAX_PAYLOAD_SIZE);
 313                 return NULL;
 314         }
 315
 316         message = talloc_size(ctx, sizeof(*message) + payload_len);
 317
 318         /* we convert these to big-endian in write_message() */
 319         message->action = action;
 320         message->payload_len = payload_len;
 321
 322         return message;
 323
 324 }
 325
 326 struct pb_protocol_message *pb_protocol_read_message(void *ctx, int fd)
 327 {
 328         struct pb_protocol_message *message, m;
 329         int rc;
 330         unsigned int len;
 331
 332         /* use the stack for the initial 8-byte read */
 333
 334         rc = read(fd, &m, sizeof(m));
 335         if (rc != sizeof(m))
 336                 return NULL;
 337
 338         m.payload_len = __be32_to_cpu(m.payload_len);
 339         m.action = __be32_to_cpu(m.action);
 340
 341         if (m.payload_len > PB_PROTOCOL_MAX_PAYLOAD_SIZE) {
 342                 pb_log("%s: payload too big %u/%u\n", __func__, m.payload_len,
 343                         PB_PROTOCOL_MAX_PAYLOAD_SIZE);
 344                 return NULL;
 345         }
 346
 347         message = talloc_size(ctx, sizeof(m) + m.payload_len);
 348         memcpy(message, &m, sizeof(m));
 349
 350         for (len = 0; len < m.payload_len;) {
 351                 rc = read(fd, message->payload + len, m.payload_len - len);
 352
 353                 if (rc <= 0) {
 354                         talloc_free(message);
 355                         pb_log("%s: failed (%u): %s\n", __func__, len,
 356                                 strerror(errno));
 357                         return NULL;
 358                 }
 359
 360                 len += rc;
 361         }
 362
 363         return message;
 364 }
 365
 366
 367 int pb_protocol_deserialise_device(struct device *dev,
 368                 const struct pb_protocol_message *message)
 369 {
 370         unsigned int len;
 371         const char *pos;
 372         int rc = -1;
 373
 374         len = message->payload_len;
 375         pos = message->payload;
 376
 377         if (read_string(dev, &pos, &len, &dev->id))
 378                 goto out;
 379
 380         if (read_string(dev, &pos, &len, &dev->name))
 381                 goto out;
 382
 383         if (read_string(dev, &pos, &len, &dev->description))
 384                 goto out;
 385
 386         if (read_string(dev, &pos, &len, &dev->icon_file))
 387                 goto out;
 388
 389         rc = 0;
 390
 391 out:
 392         return rc;
 393 }
 394
 395 int pb_protocol_deserialise_boot_option(struct boot_option *opt,
 396                 const struct pb_protocol_message *message)
 397 {
 398         unsigned int len;
 399         const char *pos;
 400         int rc = -1;
 401
 402         len = message->payload_len;
 403         pos = message->payload;
 404
 405         if (read_string(opt, &pos, &len, &opt->device_id))
 406                 goto out;
 407
 408         if (read_string(opt, &pos, &len, &opt->id))
 409                 goto out;
 410
 411         if (read_string(opt, &pos, &len, &opt->name))
 412                 goto out;
 413
 414         if (read_string(opt, &pos, &len, &opt->description))
 415                 goto out;
 416
 417         if (read_string(opt, &pos, &len, &opt->icon_file))
 418                 goto out;
 419
 420         if (read_string(opt, &pos, &len, &opt->boot_image_file))
 421                 goto out;
 422
 423         if (read_string(opt, &pos, &len, &opt->initrd_file))
 424                 goto out;
 425
 426         if (read_string(opt, &pos, &len, &opt->boot_args))
 427                 goto out;
 428
 429         if (len < sizeof(bool))
 430                 goto out;
 431         opt->is_default = *(bool *)(pos);
 432
 433         rc = 0;
 434
 435 out:
 436         return rc;
 437 }
 438
 439 int pb_protocol_deserialise_boot_command(struct boot_command *cmd,
 440                 const struct pb_protocol_message *message)
 441 {
 442         unsigned int len;
 443         const char *pos;
 444         int rc = -1;
 445
 446         len = message->payload_len;
 447         pos = message->payload;
 448
 449         if (read_string(cmd, &pos, &len, &cmd->option_id))
 450                 goto out;
 451
 452         if (read_string(cmd, &pos, &len, &cmd->boot_image_file))
 453                 goto out;
 454
 455         if (read_string(cmd, &pos, &len, &cmd->initrd_file))
 456                 goto out;
 457
 458         if (read_string(cmd, &pos, &len, &cmd->boot_args))
 459                 goto out;
 460
 461         rc = 0;
 462
 463 out:
 464         return rc;
 465 }
 466
 467 int pb_protocol_deserialise_boot_status(struct boot_status *status,
 468                 const struct pb_protocol_message *message)
 469 {
 470         unsigned int len;
 471         const char *pos;
 472         int rc = -1;
 473
 474         len = message->payload_len;
 475         pos = message->payload;
 476
 477         /* first up, the type enum... */
 478         if (len < sizeof(uint32_t))
 479                 goto out;
 480
 481         status->type = __be32_to_cpu(*(uint32_t *)(pos));
 482
 483         switch (status->type) {
 484         case BOOT_STATUS_ERROR:
 485         case BOOT_STATUS_INFO:
 486                 break;
 487         default:
 488                 goto out;
 489         }
 490
 491         pos += sizeof(uint32_t);
 492         len -= sizeof(uint32_t);
 493
 494         /* message and detail strings */
 495         if (read_string(status, &pos, &len, &status->message))
 496                 goto out;
 497
 498         if (read_string(status, &pos, &len, &status->detail))
 499                 goto out;
 500
 501         /* and finally, progress */
 502         if (len < sizeof(uint32_t))
 503                 goto out;
 504
 505         status->progress = __be32_to_cpu(*(uint32_t *)(pos));
 506
 507         /* clamp to 100% */
 508         if (status->progress > 100)
 509                 status->progress = 100;
 510
 511         rc = 0;
 512
 513 out:
 514         return rc;
 515 }