1 /****************************************************************************** 2 * 3 * Module Name: acfileio - Get ACPI tables from file 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2022, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include "acpi.h" 45 #include "accommon.h" 46 #include "actables.h" 47 #include "acutils.h" 48 #include "acapps.h" 49 50 #define _COMPONENT ACPI_UTILITIES 51 ACPI_MODULE_NAME ("acfileio") 52 53 54 /* Local prototypes */ 55 56 static ACPI_STATUS 57 AcGetOneTableFromFile ( 58 char *Filename, 59 FILE *File, 60 UINT8 GetOnlyAmlTables, 61 ACPI_TABLE_HEADER **Table); 62 63 static ACPI_STATUS 64 AcCheckTextModeCorruption ( 65 ACPI_TABLE_HEADER *Table); 66 67 68 /******************************************************************************* 69 * 70 * FUNCTION: AcDeleteTableList 71 * 72 * PARAMETERS: ListHead - List to delete 73 * 74 * RETURN: Status 75 * 76 * DESCRIPTION: Delete a list of tables. This is useful for removing memory 77 * allocated by AcGetAllTablesFromFile 78 * 79 ******************************************************************************/ 80 81 void 82 AcDeleteTableList ( 83 ACPI_NEW_TABLE_DESC *ListHead) 84 { 85 ACPI_NEW_TABLE_DESC *Current = ListHead; 86 ACPI_NEW_TABLE_DESC *Previous = Current; 87 88 89 while (Current) 90 { 91 Current = Current->Next; 92 AcpiOsFree (Previous); 93 Previous = Current; 94 } 95 } 96 97 98 /******************************************************************************* 99 * 100 * FUNCTION: AcGetAllTablesFromFile 101 * 102 * PARAMETERS: Filename - Table filename 103 * GetOnlyAmlTables - TRUE if the tables must be AML tables 104 * ReturnListHead - Where table list is returned 105 * 106 * RETURN: Status 107 * 108 * DESCRIPTION: Get all ACPI tables from within a single file. 109 * 110 ******************************************************************************/ 111 112 ACPI_STATUS 113 AcGetAllTablesFromFile ( 114 char *Filename, 115 UINT8 GetOnlyAmlTables, 116 ACPI_NEW_TABLE_DESC **ReturnListHead) 117 { 118 ACPI_NEW_TABLE_DESC *ListHead = NULL; 119 ACPI_NEW_TABLE_DESC *ListTail = NULL; 120 ACPI_NEW_TABLE_DESC *TableDesc; 121 FILE *File; 122 ACPI_TABLE_HEADER *Table = NULL; 123 UINT32 FileSize; 124 ACPI_STATUS Status = AE_OK; 125 126 127 File = fopen (Filename, "rb"); 128 if (!File) 129 { 130 fprintf (stderr, "Could not open input file: %s\n", Filename); 131 if (errno == ENOENT) 132 { 133 return (AE_NOT_EXIST); 134 } 135 136 return (AE_ERROR); 137 } 138 139 /* Get the file size */ 140 141 FileSize = CmGetFileSize (File); 142 if (FileSize == ACPI_UINT32_MAX) 143 { 144 Status = AE_ERROR; 145 goto Exit; 146 } 147 148 fprintf (stderr, 149 "Input file %s, Length 0x%X (%u) bytes\n", 150 Filename, FileSize, FileSize); 151 152 /* We must have at least one ACPI table header */ 153 154 if (FileSize < sizeof (ACPI_TABLE_HEADER)) 155 { 156 Status = AE_BAD_HEADER; 157 goto Exit; 158 } 159 160 /* Check for an non-binary file */ 161 162 if (!AcIsFileBinary (File)) 163 { 164 fprintf (stderr, 165 " %s: File does not appear to contain a valid AML table\n", 166 Filename); 167 Status = AE_TYPE; 168 goto Exit; 169 } 170 171 /* Read all tables within the file */ 172 173 while (ACPI_SUCCESS (Status)) 174 { 175 /* Get one entire ACPI table */ 176 177 Status = AcGetOneTableFromFile ( 178 Filename, File, GetOnlyAmlTables, &Table); 179 180 if (Status == AE_CTRL_TERMINATE) 181 { 182 Status = AE_OK; 183 break; 184 } 185 else if (Status == AE_TYPE) 186 { 187 Status = AE_OK; 188 goto Exit; 189 } 190 else if (ACPI_FAILURE (Status)) 191 { 192 goto Exit; 193 } 194 195 /* Print table header for iASL/disassembler only */ 196 197 #ifdef ACPI_ASL_COMPILER 198 199 AcpiTbPrintTableHeader (0, Table); 200 #endif 201 202 /* Allocate and link a table descriptor */ 203 204 TableDesc = AcpiOsAllocate (sizeof (ACPI_NEW_TABLE_DESC)); 205 if (!TableDesc) 206 { 207 AcpiOsFree (Table); 208 Status = AE_NO_MEMORY; 209 goto Exit; 210 } 211 212 TableDesc->Table = Table; 213 TableDesc->Next = NULL; 214 215 /* Link at the end of the local table list */ 216 217 if (!ListHead) 218 { 219 ListHead = TableDesc; 220 ListTail = TableDesc; 221 } 222 else 223 { 224 ListTail->Next = TableDesc; 225 ListTail = TableDesc; 226 } 227 } 228 229 /* Add the local table list to the end of the global list */ 230 231 if (*ReturnListHead) 232 { 233 ListTail = *ReturnListHead; 234 while (ListTail->Next) 235 { 236 ListTail = ListTail->Next; 237 } 238 239 ListTail->Next = ListHead; 240 } 241 else 242 { 243 *ReturnListHead = ListHead; 244 } 245 246 Exit: 247 fclose(File); 248 return (Status); 249 } 250 251 252 /******************************************************************************* 253 * 254 * FUNCTION: AcGetOneTableFromFile 255 * 256 * PARAMETERS: Filename - File where table is located 257 * File - Open FILE pointer to Filename 258 * GetOnlyAmlTables - TRUE if the tables must be AML tables. 259 * ReturnTable - Where a pointer to the table is returned 260 * 261 * RETURN: Status 262 * 263 * DESCRIPTION: Read the next ACPI table from a file. Implements support 264 * for multiple tables within a single file. File must already 265 * be open. 266 * 267 * Note: Loading an RSDP is not supported. 268 * 269 ******************************************************************************/ 270 271 static ACPI_STATUS 272 AcGetOneTableFromFile ( 273 char *Filename, 274 FILE *File, 275 UINT8 GetOnlyAmlTables, 276 ACPI_TABLE_HEADER **ReturnTable) 277 { 278 ACPI_STATUS Status = AE_OK; 279 ACPI_TABLE_HEADER TableHeader; 280 ACPI_TABLE_HEADER *Table; 281 INT32 Count; 282 UINT32 TableLength; 283 UINT32 HeaderLength; 284 long TableOffset = 0; 285 286 *ReturnTable = NULL; 287 288 /* Get the table header to examine signature and length */ 289 /* 290 * Special handling for the CDAT table (both the Length field 291 * and the Checksum field are not in the standard positions). 292 * (The table header is non-standard). 293 */ 294 if (AcpiGbl_CDAT) 295 { 296 HeaderLength = sizeof (ACPI_TABLE_CDAT); 297 } 298 else 299 { 300 HeaderLength = sizeof (ACPI_TABLE_HEADER); 301 } 302 303 Status = AcValidateTableHeader (File, TableOffset); 304 if (ACPI_FAILURE (Status)) 305 { 306 return (Status); 307 } 308 309 TableOffset = ftell (File); 310 Count = fread (&TableHeader, 1, HeaderLength, File); 311 if (Count != (INT32) HeaderLength) 312 { 313 return (AE_CTRL_TERMINATE); 314 } 315 316 if (GetOnlyAmlTables) 317 { 318 /* Validate the table signature/header (limited ASCII chars) */ 319 320 /* 321 * Table must be an AML table (DSDT/SSDT). 322 * Used for iASL -e option only. 323 */ 324 if (!AcpiUtIsAmlTable (&TableHeader)) 325 { 326 fprintf (stderr, 327 " %s: Table [%4.4s] is not an AML table - ignoring\n", 328 Filename, TableHeader.Signature); 329 330 return (AE_TYPE); 331 } 332 } 333 334 /* 335 * Special handling for the CDAT table (both the Length field 336 * and the Checksum field are not in the standard positions). 337 */ 338 if (AcpiGbl_CDAT) 339 { 340 TableLength = ACPI_CAST_PTR (ACPI_TABLE_CDAT, &TableHeader)->Length; 341 } 342 else 343 { 344 TableLength = TableHeader.Length; 345 } 346 347 /* Allocate a buffer for the entire table */ 348 349 Table = AcpiOsAllocate ((ACPI_SIZE) TableLength); 350 if (!Table) 351 { 352 return (AE_NO_MEMORY); 353 } 354 355 /* Read the entire ACPI table, including header */ 356 357 fseek (File, TableOffset, SEEK_SET); 358 Count = fread (Table, 1, TableLength, File); 359 360 /* 361 * Checks for data table headers happen later in the execution. Only verify 362 * for Aml tables at this point in the code. 363 */ 364 if (GetOnlyAmlTables && Count != (INT32) TableLength) 365 { 366 Status = AE_ERROR; 367 goto ErrorExit; 368 } 369 370 /* 371 * Validate the checksum (just issue a warning if incorrect). 372 * Note: CDAT is special cased here because the table does 373 * not have the checksum field in the standard position. 374 */ 375 if (AcpiGbl_CDAT) 376 { 377 Status = AcpiUtVerifyCdatChecksum ((ACPI_TABLE_CDAT *) Table, TableLength); 378 } else 379 { 380 Status = AcpiUtVerifyChecksum (Table, TableLength); 381 } 382 383 if (ACPI_FAILURE (Status)) 384 { 385 Status = AcCheckTextModeCorruption (Table); 386 if (ACPI_FAILURE (Status)) 387 { 388 goto ErrorExit; 389 } 390 } 391 392 *ReturnTable = Table; 393 return (AE_OK); 394 395 396 ErrorExit: 397 AcpiOsFree (Table); 398 return (Status); 399 } 400 401 402 /******************************************************************************* 403 * 404 * FUNCTION: AcIsFileBinary 405 * 406 * PARAMETERS: File - Open input file 407 * 408 * RETURN: TRUE if file appears to be binary 409 * 410 * DESCRIPTION: Scan a file for any non-ASCII bytes. 411 * 412 * Note: Maintains current file position. 413 * 414 ******************************************************************************/ 415 416 BOOLEAN 417 AcIsFileBinary ( 418 FILE *File) 419 { 420 UINT8 Byte; 421 BOOLEAN IsBinary = FALSE; 422 long FileOffset; 423 424 425 /* Scan entire file for any non-ASCII bytes */ 426 427 FileOffset = ftell (File); 428 while (fread (&Byte, 1, 1, File) == 1) 429 { 430 if (!isprint (Byte) && !isspace (Byte)) 431 { 432 IsBinary = TRUE; 433 goto Exit; 434 } 435 } 436 437 Exit: 438 fseek (File, FileOffset, SEEK_SET); 439 return (IsBinary); 440 } 441 442 443 /******************************************************************************* 444 * 445 * FUNCTION: AcValidateTableHeader 446 * 447 * PARAMETERS: File - Open input file 448 * 449 * RETURN: Status 450 * 451 * DESCRIPTION: Determine if a file seems to contain one or more binary ACPI 452 * tables, via the 453 * following checks on what would be the table header: 454 * 1) File must be at least as long as an ACPI_TABLE_HEADER 455 * 2) There must be enough room in the file to hold entire table 456 * 3) Signature, OemId, OemTableId, AslCompilerId must be ASCII 457 * 458 * Note: There can be multiple definition blocks per file, so we cannot 459 * expect/compare the file size to be equal to the table length. 12/2015. 460 * 461 * Note: Maintains current file position. 462 * 463 ******************************************************************************/ 464 465 ACPI_STATUS 466 AcValidateTableHeader ( 467 FILE *File, 468 long TableOffset) 469 { 470 ACPI_TABLE_HEADER TableHeader; 471 ACPI_TABLE_CDAT *CdatTableHeader = ACPI_CAST_PTR (ACPI_TABLE_CDAT, &TableHeader); 472 UINT32 HeaderLength; 473 ACPI_SIZE Actual; 474 long OriginalOffset; 475 UINT32 FileSize; 476 UINT32 i; 477 478 479 ACPI_FUNCTION_TRACE (AcValidateTableHeader); 480 481 /* Determine the type of table header */ 482 483 if (AcpiGbl_CDAT) 484 { 485 HeaderLength = sizeof (ACPI_TABLE_CDAT); 486 } 487 else 488 { 489 HeaderLength = sizeof (ACPI_TABLE_HEADER); 490 } 491 492 /* Read a potential table header */ 493 494 OriginalOffset = ftell (File); 495 if (fseek (File, TableOffset, SEEK_SET)) 496 { 497 fprintf (stderr, "SEEK error\n"); 498 } 499 Actual = fread (&TableHeader, 1, HeaderLength, File); 500 if (fseek (File, OriginalOffset, SEEK_SET)) 501 { 502 fprintf (stderr, "SEEK error\n"); 503 } 504 505 if (Actual < HeaderLength) 506 { 507 fprintf (stderr, 508 "Could not read entire table header: Actual %u, Requested %u\n", 509 (UINT32) Actual, HeaderLength); 510 return (AE_ERROR); 511 } 512 513 /* Validate the signature (limited ASCII chars) */ 514 515 if (!AcpiGbl_CDAT && !AcpiUtValidNameseg (TableHeader.Signature)) 516 { 517 /* 518 * The "-ds cdat" option was not used, and the signature is not valid. 519 * 520 * For CDAT we are assuming that there should be at least one non-ASCII 521 * byte in the (normally) 4-character Signature field (at least the 522 * high-order byte should be zero). Otherwise, this is OK. 523 */ 524 fprintf (stderr, 525 "\nTable appears to be a CDAT table, which has no signature.\n" 526 "If this is in fact a CDAT table, use the -ds option on the\n" 527 "command line to specify the table type (signature):\n" 528 "\"iasl -d -ds CDAT <file>\" or \"iasl -ds CDAT -T CDAT\"\n\n"); 529 530 return (AE_BAD_SIGNATURE); 531 } 532 533 /* Validate table length against bytes remaining in the file */ 534 535 FileSize = CmGetFileSize (File); 536 if (!AcpiGbl_CDAT) 537 { 538 /* Standard ACPI table header */ 539 540 if (TableHeader.Length > (UINT32) (FileSize - TableOffset)) 541 { 542 fprintf (stderr, "Table [%4.4s] is too long for file - " 543 "needs: 0x%.2X, remaining in file: 0x%.2X\n", 544 TableHeader.Signature, TableHeader.Length, 545 (UINT32) (FileSize - TableOffset)); 546 return (AE_BAD_HEADER); 547 } 548 } 549 else if (CdatTableHeader->Length > (UINT32) (FileSize - TableOffset)) 550 { 551 /* Special header for CDAT table */ 552 553 fprintf (stderr, "Table [CDAT] is too long for file - " 554 "needs: 0x%.2X, remaining in file: 0x%.2X\n", 555 CdatTableHeader->Length, 556 (UINT32) (FileSize - TableOffset)); 557 return (AE_BAD_HEADER); 558 } 559 560 /* For CDAT table, there are no ASCII fields in the header, we are done */ 561 562 if (AcpiGbl_CDAT) 563 { 564 return (AE_OK); 565 } 566 567 /* 568 * These standard fields must be ASCII: OemId, OemTableId, AslCompilerId. 569 * We allow a NULL terminator in OemId and OemTableId. 570 */ 571 for (i = 0; i < ACPI_NAMESEG_SIZE; i++) 572 { 573 if (!ACPI_IS_ASCII ((UINT8) TableHeader.AslCompilerId[i])) 574 { 575 goto BadCharacters; 576 } 577 } 578 579 for (i = 0; (i < ACPI_OEM_ID_SIZE) && (TableHeader.OemId[i]); i++) 580 { 581 if (!ACPI_IS_ASCII ((UINT8) TableHeader.OemId[i])) 582 { 583 goto BadCharacters; 584 } 585 } 586 587 for (i = 0; (i < ACPI_OEM_TABLE_ID_SIZE) && (TableHeader.OemTableId[i]); i++) 588 { 589 if (!ACPI_IS_ASCII ((UINT8) TableHeader.OemTableId[i])) 590 { 591 goto BadCharacters; 592 } 593 } 594 595 return (AE_OK); 596 597 598 BadCharacters: 599 600 ACPI_WARNING ((AE_INFO, 601 "Table header for [%4.4s] has invalid ASCII character(s)", 602 TableHeader.Signature)); 603 return (AE_OK); 604 } 605 606 607 /******************************************************************************* 608 * 609 * FUNCTION: AcCheckTextModeCorruption 610 * 611 * PARAMETERS: Table - Table buffer starting with table header 612 * 613 * RETURN: Status 614 * 615 * DESCRIPTION: Check table for text mode file corruption where all linefeed 616 * characters (LF) have been replaced by carriage return linefeed 617 * pairs (CR/LF). 618 * 619 ******************************************************************************/ 620 621 static ACPI_STATUS 622 AcCheckTextModeCorruption ( 623 ACPI_TABLE_HEADER *Table) 624 { 625 UINT32 i; 626 UINT32 Pairs = 0; 627 UINT8 *Buffer = ACPI_CAST_PTR (UINT8, Table); 628 629 630 /* Scan entire table to determine if each LF has been prefixed with a CR */ 631 632 for (i = 1; i < Table->Length; i++) 633 { 634 if (Buffer[i] == 0x0A) 635 { 636 if (Buffer[i - 1] != 0x0D) 637 { 638 /* The LF does not have a preceding CR, table not corrupted */ 639 640 return (AE_OK); 641 } 642 else 643 { 644 /* Found a CR/LF pair */ 645 646 Pairs++; 647 } 648 649 i++; 650 } 651 } 652 653 if (!Pairs) 654 { 655 return (AE_OK); 656 } 657 658 /* 659 * Entire table scanned, each CR is part of a CR/LF pair -- 660 * meaning that the table was treated as a text file somewhere. 661 * 662 * NOTE: We can't "fix" the table, because any existing CR/LF pairs in the 663 * original table are left untouched by the text conversion process -- 664 * meaning that we cannot simply replace CR/LF pairs with LFs. 665 */ 666 AcpiOsPrintf ("Table has been corrupted by text mode conversion\n"); 667 AcpiOsPrintf ("All LFs (%u) were changed to CR/LF pairs\n", Pairs); 668 AcpiOsPrintf ("Table cannot be repaired!\n"); 669 670 return (AE_BAD_VALUE); 671 } 672