1 /* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later */ 2 #include "array.h" 3 4 #include <libpldm/base.h> 5 #include <libpldm/bios.h> 6 #include <libpldm/bios_table.h> 7 #include <libpldm/utils.h> 8 9 #include <assert.h> 10 #include <endian.h> 11 #include <limits.h> 12 #include <stdbool.h> 13 #include <stdint.h> 14 #include <stdlib.h> 15 #include <string.h> 16 17 #define POINTER_CHECK(pointer) \ 18 do { \ 19 if ((pointer) == NULL) \ 20 return PLDM_ERROR_INVALID_DATA; \ 21 } while (0) 22 23 #define ATTR_TYPE_EXPECT(type, expected) \ 24 do { \ 25 if ((type) != (expected) && (type) != ((expected) | 0x80)) \ 26 return PLDM_ERROR_INVALID_DATA; \ 27 } while (0) 28 29 #define BUFFER_SIZE_EXPECT(current_size, expected_size) \ 30 do { \ 31 if ((current_size) < (expected_size)) \ 32 return PLDM_ERROR_INVALID_LENGTH; \ 33 } while (0) 34 35 #define MEMBER_SIZE(type, member) sizeof(((struct type *)0)->member) 36 37 static void set_errmsg(const char **errmsg, const char *msg) 38 { 39 if (errmsg != NULL) { 40 *errmsg = msg; 41 } 42 } 43 44 static int get_bios_string_handle(uint16_t *val) 45 { 46 static uint16_t handle = 0; 47 assert(handle != UINT16_MAX); 48 if (handle == UINT16_MAX) { 49 return PLDM_ERROR_INVALID_DATA; 50 } 51 52 *val = handle++; 53 return PLDM_SUCCESS; 54 } 55 56 LIBPLDM_ABI_STABLE 57 size_t pldm_bios_table_string_entry_encode_length(uint16_t string_length) 58 { 59 return sizeof(struct pldm_bios_string_table_entry) - 60 MEMBER_SIZE(pldm_bios_string_table_entry, name) + string_length; 61 } 62 63 LIBPLDM_ABI_STABLE 64 int pldm_bios_table_string_entry_encode(void *entry, size_t entry_length, 65 const char *str, uint16_t str_length) 66 { 67 if (str_length == 0) { 68 return PLDM_ERROR_INVALID_DATA; 69 } 70 POINTER_CHECK(entry); 71 POINTER_CHECK(str); 72 size_t length = pldm_bios_table_string_entry_encode_length(str_length); 73 BUFFER_SIZE_EXPECT(entry_length, length); 74 struct pldm_bios_string_table_entry *string_entry = entry; 75 uint16_t handle; 76 int rc = get_bios_string_handle(&handle); 77 if (rc != PLDM_SUCCESS) { 78 return rc; 79 } 80 string_entry->string_handle = htole16(handle); 81 string_entry->string_length = htole16(str_length); 82 memcpy(string_entry->name, str, str_length); 83 return PLDM_SUCCESS; 84 } 85 86 LIBPLDM_ABI_STABLE 87 uint16_t pldm_bios_table_string_entry_decode_handle( 88 const struct pldm_bios_string_table_entry *entry) 89 { 90 return le16toh(entry->string_handle); 91 } 92 93 LIBPLDM_ABI_STABLE 94 uint16_t pldm_bios_table_string_entry_decode_string_length( 95 const struct pldm_bios_string_table_entry *entry) 96 { 97 return le16toh(entry->string_length); 98 } 99 100 LIBPLDM_ABI_STABLE 101 int pldm_bios_table_string_entry_decode_string( 102 const struct pldm_bios_string_table_entry *entry, char *buffer, 103 size_t size) 104 { 105 POINTER_CHECK(entry); 106 POINTER_CHECK(buffer); 107 if (size == 0) { 108 return PLDM_ERROR_INVALID_LENGTH; 109 } 110 size_t length = 111 pldm_bios_table_string_entry_decode_string_length(entry); 112 length = length < (size - 1) ? length : (size - 1); 113 memcpy(buffer, entry->name, length); 114 buffer[length] = 0; 115 return PLDM_SUCCESS; 116 } 117 118 static ssize_t string_table_entry_length(const void *table_entry) 119 { 120 const struct pldm_bios_string_table_entry *entry = table_entry; 121 size_t len = sizeof(*entry) - sizeof(entry->name) + 122 pldm_bios_table_string_entry_decode_string_length(entry); 123 if (len > SSIZE_MAX) { 124 return -1; 125 } 126 return (ssize_t)len; 127 } 128 129 static int get_bios_attr_handle(uint16_t *val) 130 { 131 static uint16_t handle = 0; 132 assert(handle != UINT16_MAX); 133 if (handle == UINT16_MAX) { 134 return PLDM_ERROR_INVALID_DATA; 135 } 136 137 *val = handle++; 138 return PLDM_SUCCESS; 139 } 140 141 static int attr_table_entry_encode_header(void *entry, size_t length, 142 uint8_t attr_type, 143 uint16_t string_handle) 144 { 145 struct pldm_bios_attr_table_entry *attr_entry = entry; 146 147 assert(sizeof(*attr_entry) <= length); 148 if (sizeof(*attr_entry) > length) { 149 return PLDM_ERROR_INVALID_LENGTH; 150 } 151 152 uint16_t handle; 153 int rc = get_bios_attr_handle(&handle); 154 if (rc != PLDM_SUCCESS) { 155 return rc; 156 } 157 158 attr_entry->attr_handle = htole16(handle); 159 attr_entry->attr_type = attr_type; 160 attr_entry->string_handle = htole16(string_handle); 161 162 return PLDM_SUCCESS; 163 } 164 165 LIBPLDM_ABI_STABLE 166 uint16_t pldm_bios_table_attr_entry_decode_attribute_handle( 167 const struct pldm_bios_attr_table_entry *entry) 168 { 169 return le16toh(entry->attr_handle); 170 } 171 172 LIBPLDM_ABI_STABLE 173 uint8_t pldm_bios_table_attr_entry_decode_attribute_type( 174 const struct pldm_bios_attr_table_entry *entry) 175 { 176 return entry->attr_type; 177 } 178 179 LIBPLDM_ABI_STABLE 180 uint16_t pldm_bios_table_attr_entry_decode_string_handle( 181 const struct pldm_bios_attr_table_entry *entry) 182 { 183 return le16toh(entry->string_handle); 184 } 185 186 LIBPLDM_ABI_STABLE 187 size_t pldm_bios_table_attr_entry_enum_encode_length(uint8_t pv_num, 188 uint8_t def_num) 189 { 190 return sizeof(struct pldm_bios_attr_table_entry) - 191 MEMBER_SIZE(pldm_bios_attr_table_entry, metadata) + 192 sizeof(pv_num) + pv_num * sizeof(uint16_t) + sizeof(def_num) + 193 def_num; 194 } 195 196 LIBPLDM_ABI_STABLE 197 int pldm_bios_table_attr_entry_enum_encode( 198 void *entry, size_t entry_length, 199 const struct pldm_bios_table_attr_entry_enum_info *info) 200 { 201 POINTER_CHECK(entry); 202 POINTER_CHECK(info); 203 size_t length = pldm_bios_table_attr_entry_enum_encode_length( 204 info->pv_num, info->def_num); 205 BUFFER_SIZE_EXPECT(entry_length, length); 206 uint8_t attr_type = info->read_only ? PLDM_BIOS_ENUMERATION_READ_ONLY : 207 PLDM_BIOS_ENUMERATION; 208 int rc = attr_table_entry_encode_header(entry, entry_length, attr_type, 209 info->name_handle); 210 if (rc != PLDM_SUCCESS) { 211 return rc; 212 } 213 struct pldm_bios_attr_table_entry *attr_entry = entry; 214 attr_entry->metadata[0] = info->pv_num; 215 uint16_t *pv_hdls = 216 (uint16_t *)(attr_entry->metadata + 1 /* sizeof(pv num) */); 217 size_t i; 218 for (i = 0; i < info->pv_num; i++) { 219 pv_hdls[i] = htole16(info->pv_handle[i]); 220 } 221 attr_entry->metadata[1 + info->pv_num * sizeof(uint16_t)] = 222 info->def_num; 223 memcpy(attr_entry->metadata + 1 /* sizeof(pv num) */ + 224 info->pv_num * sizeof(uint16_t) + 1 /* sizeof(def num)*/, 225 info->def_index, info->def_num); 226 return PLDM_SUCCESS; 227 } 228 229 #define ATTR_TYPE_EXPECT(type, expected) \ 230 do { \ 231 if ((type) != (expected) && (type) != ((expected) | 0x80)) \ 232 return PLDM_ERROR_INVALID_DATA; \ 233 } while (0) 234 235 LIBPLDM_ABI_STABLE 236 int pldm_bios_table_attr_entry_enum_decode_pv_num( 237 const struct pldm_bios_attr_table_entry *entry, uint8_t *pv_num) 238 { 239 POINTER_CHECK(entry); 240 POINTER_CHECK(pv_num); 241 ATTR_TYPE_EXPECT(entry->attr_type, PLDM_BIOS_ENUMERATION); 242 *pv_num = entry->metadata[0]; 243 return PLDM_SUCCESS; 244 } 245 246 LIBPLDM_ABI_STABLE 247 int pldm_bios_table_attr_entry_enum_decode_def_num( 248 const struct pldm_bios_attr_table_entry *entry, uint8_t *def_num) 249 { 250 uint8_t pv_num; 251 252 POINTER_CHECK(entry); 253 POINTER_CHECK(def_num); 254 ATTR_TYPE_EXPECT(entry->attr_type, PLDM_BIOS_ENUMERATION); 255 pv_num = entry->metadata[0]; 256 *def_num = entry->metadata[sizeof(uint8_t) + sizeof(uint16_t) * pv_num]; 257 return PLDM_SUCCESS; 258 } 259 260 LIBPLDM_ABI_STABLE 261 int pldm_bios_table_attr_entry_enum_decode_pv_hdls( 262 const struct pldm_bios_attr_table_entry *entry, uint16_t *pv_hdls, 263 uint8_t pv_num) 264 { 265 POINTER_CHECK(entry); 266 POINTER_CHECK(pv_hdls); 267 ATTR_TYPE_EXPECT(entry->attr_type, PLDM_BIOS_ENUMERATION); 268 uint8_t num = entry->metadata[0]; 269 num = num < pv_num ? num : pv_num; 270 size_t i; 271 for (i = 0; i < num; i++) { 272 uint16_t *hdl = (uint16_t *)(entry->metadata + sizeof(uint8_t) + 273 i * sizeof(uint16_t)); 274 pv_hdls[i] = le16toh(*hdl); 275 } 276 return PLDM_SUCCESS; 277 } 278 279 LIBPLDM_ABI_STABLE 280 uint8_t pldm_bios_table_attr_entry_enum_decode_def_indices( 281 const struct pldm_bios_attr_table_entry *entry, uint8_t *def_indices, 282 uint8_t def_num) 283 { 284 uint8_t num = 0; 285 286 /* TODO: Fix the API to propagate errors */ 287 pldm_bios_table_attr_entry_enum_decode_def_num(entry, &num); 288 num = num < def_num ? num : def_num; 289 uint8_t pv_num = entry->metadata[0]; 290 const uint8_t *p = entry->metadata + 291 sizeof(uint8_t) /* number of possible values*/ 292 + pv_num * sizeof(uint16_t) /* possible values */ 293 + sizeof(uint8_t); /* number of default values */ 294 memcpy(def_indices, p, num); 295 return num; 296 } 297 298 /** @brief Get length of an enum attribute entry 299 */ 300 static ssize_t attr_table_entry_length_enum(const void *arg) 301 { 302 const struct pldm_bios_attr_table_entry *entry = arg; 303 uint8_t pv_num = entry->metadata[0]; 304 uint8_t def_num = 0; 305 306 /* TODO: Fix the API to propagate errors */ 307 pldm_bios_table_attr_entry_enum_decode_def_num(entry, &def_num); 308 size_t len = 309 pldm_bios_table_attr_entry_enum_encode_length(pv_num, def_num); 310 if (len > SSIZE_MAX) { 311 return -1; 312 } 313 return (ssize_t)len; 314 } 315 316 struct attr_table_string_entry_fields { 317 uint8_t string_type; 318 uint16_t min_length; 319 uint16_t max_length; 320 uint16_t def_length; 321 uint8_t def_string[1]; 322 } __attribute__((packed)); 323 324 LIBPLDM_ABI_STABLE 325 size_t pldm_bios_table_attr_entry_string_encode_length(uint16_t def_str_len) 326 { 327 return sizeof(struct pldm_bios_attr_table_entry) - 328 MEMBER_SIZE(pldm_bios_attr_table_entry, metadata) + 329 sizeof(struct attr_table_string_entry_fields) - 330 MEMBER_SIZE(attr_table_string_entry_fields, def_string) + 331 def_str_len; 332 } 333 334 #define PLDM_STRING_TYPE_MAX 5 335 #define PLDM_STRING_TYPE_VENDOR 0xff 336 337 LIBPLDM_ABI_STABLE 338 int pldm_bios_table_attr_entry_string_info_check( 339 const struct pldm_bios_table_attr_entry_string_info *info, 340 const char **errmsg) 341 { 342 if (info->min_length > info->max_length) { 343 set_errmsg(errmsg, "MinimumStingLength should not be greater " 344 "than MaximumStringLength"); 345 return PLDM_ERROR_INVALID_DATA; 346 } 347 if (info->min_length == info->max_length && 348 info->def_length != info->min_length) { 349 set_errmsg(errmsg, "Wrong DefaultStringLength"); 350 return PLDM_ERROR_INVALID_DATA; 351 } 352 if (info->def_length > info->max_length || 353 info->def_length < info->min_length) { 354 set_errmsg(errmsg, "Wrong DefaultStringLength"); 355 return PLDM_ERROR_INVALID_DATA; 356 } 357 if (info->string_type > PLDM_STRING_TYPE_MAX && 358 info->string_type != PLDM_STRING_TYPE_VENDOR) { 359 set_errmsg(errmsg, "Wrong StringType"); 360 return PLDM_ERROR_INVALID_DATA; 361 } 362 if (info->def_string && info->def_length != strlen(info->def_string)) { 363 set_errmsg(errmsg, "Length of DefaultString should be equal to " 364 "DefaultStringLength"); 365 return PLDM_ERROR_INVALID_DATA; 366 } 367 368 return PLDM_SUCCESS; 369 } 370 371 LIBPLDM_ABI_STABLE 372 int pldm_bios_table_attr_entry_string_encode( 373 void *entry, size_t entry_length, 374 const struct pldm_bios_table_attr_entry_string_info *info) 375 { 376 POINTER_CHECK(entry); 377 POINTER_CHECK(info); 378 size_t length = pldm_bios_table_attr_entry_string_encode_length( 379 info->def_length); 380 BUFFER_SIZE_EXPECT(entry_length, length); 381 if (pldm_bios_table_attr_entry_string_info_check(info, NULL) != 382 PLDM_SUCCESS) { 383 return PLDM_ERROR_INVALID_DATA; 384 } 385 uint8_t attr_type = info->read_only ? PLDM_BIOS_STRING_READ_ONLY : 386 PLDM_BIOS_STRING; 387 int rc = attr_table_entry_encode_header(entry, entry_length, attr_type, 388 info->name_handle); 389 if (rc != PLDM_SUCCESS) { 390 return rc; 391 } 392 struct pldm_bios_attr_table_entry *attr_entry = entry; 393 struct attr_table_string_entry_fields *attr_fields = 394 (struct attr_table_string_entry_fields *)attr_entry->metadata; 395 attr_fields->string_type = info->string_type; 396 attr_fields->min_length = htole16(info->min_length); 397 attr_fields->max_length = htole16(info->max_length); 398 attr_fields->def_length = htole16(info->def_length); 399 if (info->def_length != 0 && info->def_string != NULL) { 400 memcpy(attr_fields->def_string, info->def_string, 401 info->def_length); 402 } 403 return PLDM_SUCCESS; 404 } 405 406 LIBPLDM_ABI_STABLE 407 int pldm_bios_table_attr_entry_string_decode_def_string_length( 408 const struct pldm_bios_attr_table_entry *entry, 409 uint16_t *def_string_length) 410 { 411 POINTER_CHECK(entry); 412 POINTER_CHECK(def_string_length); 413 ATTR_TYPE_EXPECT(entry->attr_type, PLDM_BIOS_STRING); 414 struct attr_table_string_entry_fields *fields = 415 (struct attr_table_string_entry_fields *)entry->metadata; 416 *def_string_length = le16toh(fields->def_length); 417 return PLDM_SUCCESS; 418 } 419 420 LIBPLDM_ABI_STABLE 421 uint8_t pldm_bios_table_attr_entry_string_decode_string_type( 422 const struct pldm_bios_attr_table_entry *entry) 423 { 424 struct attr_table_string_entry_fields *fields = 425 (struct attr_table_string_entry_fields *)entry->metadata; 426 return fields->string_type; 427 } 428 429 LIBPLDM_ABI_STABLE 430 uint16_t pldm_bios_table_attr_entry_string_decode_max_length( 431 const struct pldm_bios_attr_table_entry *entry) 432 { 433 struct attr_table_string_entry_fields *fields = 434 (struct attr_table_string_entry_fields *)entry->metadata; 435 return le16toh(fields->max_length); 436 } 437 438 LIBPLDM_ABI_STABLE 439 uint16_t pldm_bios_table_attr_entry_string_decode_min_length( 440 const struct pldm_bios_attr_table_entry *entry) 441 { 442 struct attr_table_string_entry_fields *fields = 443 (struct attr_table_string_entry_fields *)entry->metadata; 444 return le16toh(fields->min_length); 445 } 446 447 LIBPLDM_ABI_STABLE 448 uint16_t pldm_bios_table_attr_entry_string_decode_def_string( 449 const struct pldm_bios_attr_table_entry *entry, char *buffer, 450 size_t size) 451 { 452 uint16_t length = 0; 453 int rc; 454 455 if (!entry || !buffer || size == 0) { 456 return 0; 457 } 458 459 /* TODO: Rework the API to propagate the error */ 460 rc = pldm_bios_table_attr_entry_string_decode_def_string_length( 461 entry, &length); 462 if (rc != PLDM_SUCCESS) { 463 return 0; 464 } 465 466 length = length < (size - 1) ? length : (size - 1); 467 struct attr_table_string_entry_fields *fields = 468 (struct attr_table_string_entry_fields *)entry->metadata; 469 memcpy(buffer, fields->def_string, length); 470 buffer[length] = 0; 471 return length; 472 } 473 474 /** @brief Get length of a string attribute entry 475 */ 476 static ssize_t attr_table_entry_length_string(const void *entry) 477 { 478 uint16_t def_str_len = 0; 479 480 /* TODO: Rework the API to propagate the error */ 481 pldm_bios_table_attr_entry_string_decode_def_string_length( 482 entry, &def_str_len); 483 size_t len = 484 pldm_bios_table_attr_entry_string_encode_length(def_str_len); 485 if (len > SSIZE_MAX) { 486 return -1; 487 } 488 return (ssize_t)len; 489 } 490 491 struct attr_table_integer_entry_fields { 492 uint64_t lower_bound; 493 uint64_t upper_bound; 494 uint32_t scalar_increment; 495 uint64_t default_value; 496 } __attribute__((packed)); 497 498 LIBPLDM_ABI_STABLE 499 size_t pldm_bios_table_attr_entry_integer_encode_length(void) 500 { 501 return sizeof(struct pldm_bios_attr_table_entry) - 1 + 502 sizeof(struct attr_table_integer_entry_fields); 503 } 504 505 LIBPLDM_ABI_STABLE 506 int pldm_bios_table_attr_entry_integer_info_check( 507 const struct pldm_bios_table_attr_entry_integer_info *info, 508 const char **errmsg) 509 { 510 if (info->lower_bound == info->upper_bound) { 511 if (info->default_value != info->lower_bound) { 512 set_errmsg(errmsg, "Wrong DefaultValue"); 513 return PLDM_ERROR_INVALID_DATA; 514 } 515 if (info->scalar_increment != 0) { 516 set_errmsg(errmsg, "Wrong ScalarIncrement"); 517 return PLDM_ERROR_INVALID_DATA; 518 } 519 return PLDM_SUCCESS; 520 } 521 if (info->lower_bound > info->upper_bound) { 522 set_errmsg(errmsg, 523 "LowerBound should not be greater than UpperBound"); 524 return PLDM_ERROR_INVALID_DATA; 525 } 526 if (info->default_value > info->upper_bound || 527 info->default_value < info->lower_bound) { 528 set_errmsg(errmsg, "Wrong DefaultValue"); 529 return PLDM_ERROR_INVALID_DATA; 530 } 531 if (info->scalar_increment == 0) { 532 set_errmsg(errmsg, "ScalarIncrement should not be zero when " 533 "lower_bound != upper_bound"); 534 return PLDM_ERROR_INVALID_DATA; 535 } 536 if ((info->default_value - info->lower_bound) % 537 info->scalar_increment != 538 0) { 539 set_errmsg(errmsg, "Wrong DefaultValue or ScalarIncrement"); 540 return PLDM_ERROR_INVALID_DATA; 541 } 542 return PLDM_SUCCESS; 543 } 544 545 LIBPLDM_ABI_STABLE 546 int pldm_bios_table_attr_entry_integer_encode( 547 void *entry, size_t entry_length, 548 const struct pldm_bios_table_attr_entry_integer_info *info) 549 { 550 POINTER_CHECK(entry); 551 POINTER_CHECK(info); 552 size_t length = pldm_bios_table_attr_entry_integer_encode_length(); 553 BUFFER_SIZE_EXPECT(entry_length, length); 554 if (pldm_bios_table_attr_entry_integer_info_check(info, NULL) != 555 PLDM_SUCCESS) { 556 return PLDM_ERROR_INVALID_DATA; 557 } 558 uint8_t attr_type = info->read_only ? PLDM_BIOS_INTEGER_READ_ONLY : 559 PLDM_BIOS_INTEGER; 560 int rc = attr_table_entry_encode_header(entry, entry_length, attr_type, 561 info->name_handle); 562 if (rc != PLDM_SUCCESS) { 563 return rc; 564 } 565 struct pldm_bios_attr_table_entry *attr_entry = entry; 566 struct attr_table_integer_entry_fields *attr_fields = 567 (struct attr_table_integer_entry_fields *)attr_entry->metadata; 568 attr_fields->lower_bound = htole64(info->lower_bound); 569 attr_fields->upper_bound = htole64(info->upper_bound); 570 attr_fields->scalar_increment = htole32(info->scalar_increment); 571 attr_fields->default_value = htole64(info->default_value); 572 return PLDM_SUCCESS; 573 } 574 575 LIBPLDM_ABI_STABLE 576 void pldm_bios_table_attr_entry_integer_decode( 577 const struct pldm_bios_attr_table_entry *entry, uint64_t *lower, 578 uint64_t *upper, uint32_t *scalar, uint64_t *def) 579 { 580 struct attr_table_integer_entry_fields *fields = 581 (struct attr_table_integer_entry_fields *)entry->metadata; 582 *lower = le64toh(fields->lower_bound); 583 *upper = le64toh(fields->upper_bound); 584 *scalar = le32toh(fields->scalar_increment); 585 *def = le64toh(fields->default_value); 586 } 587 588 static ssize_t attr_table_entry_length_integer(const void *entry) 589 { 590 (void)entry; 591 size_t len = pldm_bios_table_attr_entry_integer_encode_length(); 592 if (len > SSIZE_MAX) { 593 return -1; 594 } 595 return (ssize_t)len; 596 } 597 598 struct table_entry_length { 599 uint8_t attr_type; 600 ssize_t (*entry_length_handler)(const void *); 601 }; 602 603 static const struct table_entry_length * 604 find_table_entry_length_by_type(uint8_t attr_type, 605 const struct table_entry_length *handlers, 606 size_t count) 607 { 608 size_t i; 609 for (i = 0; i < count; i++) { 610 if (attr_type == handlers[i].attr_type) { 611 return &handlers[i]; 612 } 613 } 614 return NULL; 615 } 616 617 static const struct table_entry_length attr_table_entries[] = { 618 { .attr_type = PLDM_BIOS_ENUMERATION, 619 .entry_length_handler = attr_table_entry_length_enum }, 620 { .attr_type = PLDM_BIOS_ENUMERATION_READ_ONLY, 621 .entry_length_handler = attr_table_entry_length_enum }, 622 { .attr_type = PLDM_BIOS_STRING, 623 .entry_length_handler = attr_table_entry_length_string }, 624 { .attr_type = PLDM_BIOS_STRING_READ_ONLY, 625 .entry_length_handler = attr_table_entry_length_string }, 626 { .attr_type = PLDM_BIOS_INTEGER, 627 .entry_length_handler = attr_table_entry_length_integer }, 628 { .attr_type = PLDM_BIOS_INTEGER_READ_ONLY, 629 .entry_length_handler = attr_table_entry_length_integer }, 630 }; 631 632 static ssize_t attr_table_entry_length(const void *table_entry) 633 { 634 const struct pldm_bios_attr_table_entry *entry = table_entry; 635 const struct table_entry_length *attr_table_entry = 636 find_table_entry_length_by_type(entry->attr_type, 637 attr_table_entries, 638 ARRAY_SIZE(attr_table_entries)); 639 assert(attr_table_entry != NULL); 640 if (!attr_table_entry) { 641 return -1; 642 } 643 assert(attr_table_entry->entry_length_handler != NULL); 644 if (!attr_table_entry->entry_length_handler) { 645 return -1; 646 } 647 648 return attr_table_entry->entry_length_handler(entry); 649 } 650 651 LIBPLDM_ABI_STABLE 652 uint16_t pldm_bios_table_attr_value_entry_decode_attribute_handle( 653 const struct pldm_bios_attr_val_table_entry *entry) 654 { 655 return le16toh(entry->attr_handle); 656 } 657 658 LIBPLDM_ABI_STABLE 659 uint8_t pldm_bios_table_attr_value_entry_decode_attribute_type( 660 const struct pldm_bios_attr_val_table_entry *entry) 661 { 662 return entry->attr_type; 663 } 664 665 LIBPLDM_ABI_STABLE 666 size_t pldm_bios_table_attr_value_entry_encode_enum_length(uint8_t count) 667 { 668 return sizeof(struct pldm_bios_attr_val_table_entry) - 1 + 669 sizeof(count) + count; 670 } 671 672 LIBPLDM_ABI_STABLE 673 uint8_t pldm_bios_table_attr_value_entry_enum_decode_number( 674 const struct pldm_bios_attr_val_table_entry *entry) 675 { 676 return entry->value[0]; 677 } 678 679 LIBPLDM_ABI_STABLE 680 uint8_t pldm_bios_table_attr_value_entry_enum_decode_handles( 681 const struct pldm_bios_attr_val_table_entry *entry, uint8_t *handles, 682 uint8_t number) 683 { 684 uint8_t curr_num = 685 pldm_bios_table_attr_value_entry_enum_decode_number(entry); 686 curr_num = number < curr_num ? number : curr_num; 687 memcpy(handles, &entry->value[1], curr_num); 688 689 return curr_num; 690 } 691 692 LIBPLDM_ABI_STABLE 693 int pldm_bios_table_attr_value_entry_encode_enum( 694 void *entry, size_t entry_length, uint16_t attr_handle, 695 uint8_t attr_type, uint8_t count, const uint8_t *handles) 696 { 697 POINTER_CHECK(entry); 698 POINTER_CHECK(handles); 699 if (count != 0 && handles == NULL) { 700 return PLDM_ERROR_INVALID_DATA; 701 } 702 ATTR_TYPE_EXPECT(attr_type, PLDM_BIOS_ENUMERATION); 703 size_t length = 704 pldm_bios_table_attr_value_entry_encode_enum_length(count); 705 BUFFER_SIZE_EXPECT(entry_length, length); 706 struct pldm_bios_attr_val_table_entry *table_entry = entry; 707 table_entry->attr_handle = htole16(attr_handle); 708 table_entry->attr_type = attr_type; 709 table_entry->value[0] = count; 710 if (count != 0) { 711 memcpy(&table_entry->value[1], handles, count); 712 } 713 return PLDM_SUCCESS; 714 } 715 716 static ssize_t attr_value_table_entry_length_enum(const void *entry) 717 { 718 uint8_t number = 719 pldm_bios_table_attr_value_entry_enum_decode_number(entry); 720 size_t len = 721 pldm_bios_table_attr_value_entry_encode_enum_length(number); 722 if (len > SSIZE_MAX) { 723 return -1; 724 } 725 return (ssize_t)len; 726 } 727 728 LIBPLDM_ABI_STABLE 729 size_t 730 pldm_bios_table_attr_value_entry_encode_string_length(uint16_t string_length) 731 { 732 return sizeof(struct pldm_bios_attr_val_table_entry) - 1 + 733 sizeof(string_length) + string_length; 734 } 735 736 LIBPLDM_ABI_STABLE 737 uint16_t pldm_bios_table_attr_value_entry_string_decode_length( 738 const struct pldm_bios_attr_val_table_entry *entry) 739 { 740 uint16_t str_length = 0; 741 memcpy(&str_length, entry->value, sizeof(str_length)); 742 return le16toh(str_length); 743 } 744 745 LIBPLDM_ABI_STABLE 746 void pldm_bios_table_attr_value_entry_string_decode_string( 747 const struct pldm_bios_attr_val_table_entry *entry, 748 struct variable_field *current_string) 749 { 750 current_string->length = 751 pldm_bios_table_attr_value_entry_string_decode_length(entry); 752 current_string->ptr = 753 entry->value + sizeof(uint16_t); // sizeof(CurrentStringLength) 754 } 755 756 LIBPLDM_ABI_STABLE 757 int pldm_bios_table_attr_value_entry_encode_string( 758 void *entry, size_t entry_length, uint16_t attr_handle, 759 uint8_t attr_type, uint16_t str_length, const char *str) 760 { 761 struct pldm_bios_attr_val_table_entry *table_entry; 762 763 POINTER_CHECK(entry); 764 if (str_length != 0 && str == NULL) { 765 return PLDM_ERROR_INVALID_DATA; 766 } 767 ATTR_TYPE_EXPECT(attr_type, PLDM_BIOS_STRING); 768 BUFFER_SIZE_EXPECT(entry_length, 769 (sizeof(*table_entry) - 1 + sizeof(str_length))); 770 table_entry = entry; 771 table_entry->attr_handle = htole16(attr_handle); 772 table_entry->attr_type = attr_type; 773 if (entry_length - (sizeof(*table_entry) - 1 + sizeof(str_length)) < 774 str_length) { 775 return PLDM_ERROR_INVALID_LENGTH; 776 } 777 memcpy(table_entry->value + sizeof(str_length), str, str_length); 778 str_length = htole16(str_length); 779 memcpy(table_entry->value, &str_length, sizeof(str_length)); 780 return PLDM_SUCCESS; 781 } 782 783 static ssize_t attr_value_table_entry_length_string(const void *entry) 784 { 785 uint16_t str_length = 786 pldm_bios_table_attr_value_entry_string_decode_length(entry); 787 size_t len = pldm_bios_table_attr_value_entry_encode_string_length( 788 str_length); 789 if (len > SSIZE_MAX) { 790 return -1; 791 } 792 return (ssize_t)len; 793 } 794 795 LIBPLDM_ABI_STABLE 796 size_t pldm_bios_table_attr_value_entry_encode_integer_length(void) 797 { 798 return sizeof(struct pldm_bios_attr_val_table_entry) - 1 + 799 sizeof(uint64_t); 800 } 801 802 LIBPLDM_ABI_STABLE 803 int pldm_bios_table_attr_value_entry_encode_integer(void *entry, 804 size_t entry_length, 805 uint16_t attr_handle, 806 uint8_t attr_type, 807 uint64_t cv) 808 { 809 POINTER_CHECK(entry); 810 size_t length = 811 pldm_bios_table_attr_value_entry_encode_integer_length(); 812 ATTR_TYPE_EXPECT(attr_type, PLDM_BIOS_INTEGER); 813 BUFFER_SIZE_EXPECT(entry_length, length); 814 struct pldm_bios_attr_val_table_entry *table_entry = entry; 815 table_entry->attr_handle = htole16(attr_handle); 816 table_entry->attr_type = attr_type; 817 cv = htole64(cv); 818 memcpy(table_entry->value, &cv, sizeof(uint64_t)); 819 return PLDM_SUCCESS; 820 } 821 822 LIBPLDM_ABI_STABLE 823 uint64_t pldm_bios_table_attr_value_entry_integer_decode_cv( 824 const struct pldm_bios_attr_val_table_entry *entry) 825 { 826 uint64_t cv = 0; 827 memcpy(&cv, entry->value, sizeof(cv)); 828 cv = le64toh(cv); 829 return cv; 830 } 831 832 static ssize_t attr_value_table_entry_length_integer(const void *entry) 833 { 834 (void)entry; 835 size_t len = pldm_bios_table_attr_value_entry_encode_integer_length(); 836 if (len > SSIZE_MAX) { 837 return -1; 838 } 839 return (ssize_t)len; 840 } 841 842 static const struct table_entry_length attr_value_table_entries[] = { 843 { .attr_type = PLDM_BIOS_ENUMERATION, 844 .entry_length_handler = attr_value_table_entry_length_enum }, 845 { .attr_type = PLDM_BIOS_ENUMERATION_READ_ONLY, 846 .entry_length_handler = attr_value_table_entry_length_enum }, 847 { .attr_type = PLDM_BIOS_STRING, 848 .entry_length_handler = attr_value_table_entry_length_string }, 849 { .attr_type = PLDM_BIOS_STRING_READ_ONLY, 850 .entry_length_handler = attr_value_table_entry_length_string }, 851 { .attr_type = PLDM_BIOS_INTEGER, 852 .entry_length_handler = attr_value_table_entry_length_integer }, 853 { .attr_type = PLDM_BIOS_INTEGER_READ_ONLY, 854 .entry_length_handler = attr_value_table_entry_length_integer }, 855 }; 856 857 static ssize_t attr_value_table_entry_length(const void *table_entry) 858 { 859 const struct pldm_bios_attr_val_table_entry *entry = table_entry; 860 const struct table_entry_length *entry_length = 861 find_table_entry_length_by_type( 862 entry->attr_type, attr_value_table_entries, 863 ARRAY_SIZE(attr_value_table_entries)); 864 assert(entry_length != NULL); 865 if (!entry_length) { 866 return -1; 867 } 868 assert(entry_length->entry_length_handler != NULL); 869 if (!entry_length->entry_length_handler) { 870 return -1; 871 } 872 873 return entry_length->entry_length_handler(entry); 874 } 875 876 LIBPLDM_ABI_STABLE 877 size_t pldm_bios_table_attr_value_entry_length( 878 const struct pldm_bios_attr_val_table_entry *entry) 879 { 880 return attr_value_table_entry_length(entry); 881 } 882 883 LIBPLDM_ABI_STABLE 884 uint16_t pldm_bios_table_attr_value_entry_decode_handle( 885 const struct pldm_bios_attr_val_table_entry *entry) 886 { 887 return le16toh(entry->attr_handle); 888 } 889 890 static size_t pad_size_get(size_t size_without_pad) 891 { 892 return (4 - (size_without_pad % 4)) % 4; 893 } 894 895 static uint8_t *pad_append(uint8_t *table_end, size_t pad_size) 896 { 897 while (pad_size--) { 898 *table_end++ = 0; 899 } 900 901 return table_end; 902 } 903 904 static uint8_t *checksum_append(uint8_t *table_end, uint32_t checksum) 905 { 906 checksum = htole32(checksum); 907 memcpy(table_end, &checksum, sizeof(checksum)); 908 909 return table_end + sizeof(checksum); 910 } 911 912 LIBPLDM_ABI_STABLE 913 size_t pldm_bios_table_pad_checksum_size(size_t size_without_pad) 914 { 915 return pad_size_get(size_without_pad) + sizeof(uint32_t); 916 } 917 918 LIBPLDM_ABI_STABLE 919 int pldm_bios_table_append_pad_checksum(void *table, size_t capacity, 920 size_t *size) 921 { 922 if (!table || !size) { 923 return PLDM_ERROR_INVALID_DATA; 924 } 925 926 size_t pad_checksum_size = pldm_bios_table_pad_checksum_size(*size); 927 928 if (SIZE_MAX - pad_checksum_size < *size) { 929 return PLDM_ERROR_INVALID_LENGTH; 930 } 931 932 size_t total_length = *size + pad_checksum_size; 933 if (capacity < total_length) { 934 return PLDM_ERROR_INVALID_LENGTH; 935 } 936 937 if (UINTPTR_MAX - *size < (uintptr_t)table) { 938 return PLDM_ERROR_INVALID_LENGTH; 939 } 940 uint8_t *table_end = (uint8_t *)table + *size; 941 size_t pad_size = pad_size_get(*size); 942 table_end = pad_append(table_end, pad_size); 943 944 uint32_t checksum = crc32(table, *size + pad_size); 945 checksum_append(table_end, checksum); 946 *size = total_length; 947 948 return PLDM_SUCCESS; 949 } 950 951 struct pldm_bios_table_iter { 952 const uint8_t *table_data; 953 size_t table_len; 954 size_t current_pos; 955 ssize_t (*entry_length_handler)(const void *table_entry); 956 }; 957 958 LIBPLDM_ABI_STABLE 959 struct pldm_bios_table_iter * 960 pldm_bios_table_iter_create(const void *table, size_t length, 961 enum pldm_bios_table_types type) 962 { 963 struct pldm_bios_table_iter *iter = malloc(sizeof(*iter)); 964 assert(iter != NULL); 965 if (!iter) { 966 return NULL; 967 } 968 iter->table_data = table; 969 iter->table_len = length; 970 iter->current_pos = 0; 971 iter->entry_length_handler = NULL; 972 switch (type) { 973 case PLDM_BIOS_STRING_TABLE: 974 iter->entry_length_handler = string_table_entry_length; 975 break; 976 case PLDM_BIOS_ATTR_TABLE: 977 iter->entry_length_handler = attr_table_entry_length; 978 break; 979 case PLDM_BIOS_ATTR_VAL_TABLE: 980 iter->entry_length_handler = attr_value_table_entry_length; 981 break; 982 } 983 984 return iter; 985 } 986 987 LIBPLDM_ABI_STABLE 988 void pldm_bios_table_iter_free(struct pldm_bios_table_iter *iter) 989 { 990 free(iter); 991 } 992 993 #define pad_and_check_max 7 994 LIBPLDM_ABI_STABLE 995 bool pldm_bios_table_iter_is_end(const struct pldm_bios_table_iter *iter) 996 { 997 ssize_t len; 998 999 if (!iter) { 1000 return true; 1001 } 1002 1003 if (iter->table_len - iter->current_pos <= pad_and_check_max) { 1004 return true; 1005 } 1006 1007 len = iter->entry_length_handler(iter->table_data + iter->current_pos); 1008 1009 return len < 0; 1010 } 1011 1012 LIBPLDM_ABI_STABLE 1013 void pldm_bios_table_iter_next(struct pldm_bios_table_iter *iter) 1014 { 1015 if (pldm_bios_table_iter_is_end(iter)) { 1016 return; 1017 } 1018 const void *entry = iter->table_data + iter->current_pos; 1019 ssize_t rc = iter->entry_length_handler(entry); 1020 /* Prevent bad behaviour by acting as if we've hit the end of the iterator */ 1021 if (rc < 0) { 1022 return; 1023 } 1024 iter->current_pos += rc; 1025 } 1026 1027 LIBPLDM_ABI_STABLE 1028 const void *pldm_bios_table_iter_value(struct pldm_bios_table_iter *iter) 1029 { 1030 return iter->table_data + iter->current_pos; 1031 } 1032 1033 typedef bool (*equal_handler)(const void *entry, const void *key); 1034 1035 static const void * 1036 pldm_bios_table_entry_find_by_iter(struct pldm_bios_table_iter *iter, 1037 const void *key, equal_handler equal) 1038 { 1039 const void *entry; 1040 while (!pldm_bios_table_iter_is_end(iter)) { 1041 entry = pldm_bios_table_iter_value(iter); 1042 if (equal(entry, key)) { 1043 return entry; 1044 } 1045 pldm_bios_table_iter_next(iter); 1046 } 1047 return NULL; 1048 } 1049 1050 static const void * 1051 pldm_bios_table_entry_find_from_table(const void *table, size_t length, 1052 enum pldm_bios_table_types type, 1053 equal_handler equal, const void *key) 1054 { 1055 struct pldm_bios_table_iter *iter = 1056 pldm_bios_table_iter_create(table, length, type); 1057 const void *entry = 1058 pldm_bios_table_entry_find_by_iter(iter, key, equal); 1059 pldm_bios_table_iter_free(iter); 1060 return entry; 1061 } 1062 1063 static bool string_table_handle_equal(const void *entry, const void *key) 1064 { 1065 const struct pldm_bios_string_table_entry *string_entry = entry; 1066 uint16_t handle = *(uint16_t *)key; 1067 if (pldm_bios_table_string_entry_decode_handle(string_entry) == 1068 handle) { 1069 return true; 1070 } 1071 return false; 1072 } 1073 1074 LIBPLDM_ABI_STABLE 1075 const struct pldm_bios_string_table_entry * 1076 pldm_bios_table_string_find_by_handle(const void *table, size_t length, 1077 uint16_t handle) 1078 { 1079 return pldm_bios_table_entry_find_from_table(table, length, 1080 PLDM_BIOS_STRING_TABLE, 1081 string_table_handle_equal, 1082 &handle); 1083 } 1084 1085 struct string_equal_arg { 1086 uint16_t str_length; 1087 const char *str; 1088 }; 1089 1090 static bool string_table_string_equal(const void *entry, const void *key) 1091 { 1092 const struct pldm_bios_string_table_entry *string_entry = entry; 1093 const struct string_equal_arg *arg = key; 1094 if (arg->str_length != 1095 pldm_bios_table_string_entry_decode_string_length(string_entry)) { 1096 return false; 1097 } 1098 if (memcmp(string_entry->name, arg->str, arg->str_length) != 0) { 1099 return false; 1100 } 1101 return true; 1102 } 1103 1104 LIBPLDM_ABI_STABLE 1105 const struct pldm_bios_string_table_entry * 1106 pldm_bios_table_string_find_by_string(const void *table, size_t length, 1107 const char *str) 1108 { 1109 uint16_t str_length = strlen(str); 1110 struct string_equal_arg arg = { str_length, str }; 1111 return pldm_bios_table_entry_find_from_table(table, length, 1112 PLDM_BIOS_STRING_TABLE, 1113 string_table_string_equal, 1114 &arg); 1115 } 1116 1117 static bool attr_table_handle_equal(const void *entry, const void *key) 1118 { 1119 uint16_t handle = *(uint16_t *)key; 1120 return pldm_bios_table_attr_entry_decode_attribute_handle(entry) == 1121 handle; 1122 } 1123 1124 LIBPLDM_ABI_STABLE 1125 const struct pldm_bios_attr_table_entry * 1126 pldm_bios_table_attr_find_by_handle(const void *table, size_t length, 1127 uint16_t handle) 1128 { 1129 return pldm_bios_table_entry_find_from_table(table, length, 1130 PLDM_BIOS_ATTR_TABLE, 1131 attr_table_handle_equal, 1132 &handle); 1133 } 1134 1135 static bool attr_table_string_handle_equal(const void *entry, const void *key) 1136 { 1137 uint16_t handle = *(uint16_t *)key; 1138 return pldm_bios_table_attr_entry_decode_string_handle(entry) == handle; 1139 } 1140 1141 LIBPLDM_ABI_STABLE 1142 const struct pldm_bios_attr_table_entry * 1143 pldm_bios_table_attr_find_by_string_handle(const void *table, size_t length, 1144 uint16_t handle) 1145 { 1146 return pldm_bios_table_entry_find_from_table( 1147 table, length, PLDM_BIOS_ATTR_TABLE, 1148 attr_table_string_handle_equal, &handle); 1149 } 1150 1151 static bool attr_value_table_handle_equal(const void *entry, const void *key) 1152 { 1153 uint16_t handle = *(uint16_t *)key; 1154 return pldm_bios_table_attr_value_entry_decode_handle(entry) == handle; 1155 } 1156 1157 LIBPLDM_ABI_STABLE 1158 const struct pldm_bios_attr_val_table_entry * 1159 pldm_bios_table_attr_value_find_by_handle(const void *table, size_t length, 1160 uint16_t handle) 1161 { 1162 return pldm_bios_table_entry_find_from_table( 1163 table, length, PLDM_BIOS_ATTR_VAL_TABLE, 1164 attr_value_table_handle_equal, &handle); 1165 } 1166 1167 LIBPLDM_ABI_STABLE 1168 int pldm_bios_table_attr_value_copy_and_update( 1169 const void *src_table, size_t src_length, void *dest_table, 1170 size_t *dest_length, const void *entry, size_t entry_length) 1171 { 1172 struct pldm_bios_table_iter *iter = pldm_bios_table_iter_create( 1173 src_table, src_length, PLDM_BIOS_ATTR_VAL_TABLE); 1174 1175 int rc = PLDM_SUCCESS; 1176 const struct pldm_bios_attr_val_table_entry *tmp; 1177 const struct pldm_bios_attr_val_table_entry *to_update = entry; 1178 size_t buffer_length = *dest_length; 1179 size_t copied_length = 0; 1180 size_t length = 0; 1181 while (!pldm_bios_table_iter_is_end(iter)) { 1182 tmp = pldm_bios_table_iter_attr_value_entry_value(iter); 1183 length = attr_value_table_entry_length(tmp); 1184 1185 /* we need the tmp's entry_length here, iter_next will calculate 1186 * it too, use current_pos directly to avoid calculating it 1187 * twice */ 1188 iter->current_pos += length; 1189 if (tmp->attr_handle == to_update->attr_handle) { 1190 if (tmp->attr_type != to_update->attr_type) { 1191 rc = PLDM_ERROR_INVALID_DATA; 1192 goto out; 1193 } 1194 length = entry_length; 1195 tmp = entry; 1196 } 1197 if (copied_length + length > buffer_length) { 1198 rc = PLDM_ERROR_INVALID_LENGTH; 1199 goto out; 1200 } 1201 memcpy((uint8_t *)dest_table + copied_length, tmp, length); 1202 copied_length += length; 1203 } 1204 1205 size_t pad_checksum_size = 1206 pldm_bios_table_pad_checksum_size(copied_length); 1207 if ((pad_checksum_size + copied_length) > buffer_length) { 1208 rc = PLDM_ERROR_INVALID_LENGTH; 1209 goto out; 1210 } 1211 1212 rc = pldm_bios_table_append_pad_checksum(dest_table, buffer_length, 1213 &copied_length); 1214 if (rc == PLDM_SUCCESS) { 1215 *dest_length = copied_length; 1216 } 1217 out: 1218 pldm_bios_table_iter_free(iter); 1219 return rc; 1220 } 1221 1222 LIBPLDM_ABI_STABLE 1223 bool pldm_bios_table_checksum(const uint8_t *table, size_t size) 1224 { 1225 if (table == NULL) { 1226 return false; 1227 } 1228 1229 // 12: BIOSStringHandle(uint16) + BIOSStringLength(uint16) + 1230 // Variable(4) + checksum(uint32) 1231 if (size < 12) { 1232 return false; 1233 } 1234 1235 uint32_t src_crc = le32toh(*(uint32_t *)(table + size - 4)); 1236 uint32_t dst_crc = crc32(table, size - 4); 1237 1238 return src_crc == dst_crc; 1239 } 1240