text: /******************************************************************************
   *
   * Module Name: abcompare - compare AML files
   *
   *****************************************************************************/
  
  /******************************************************************************
   *
   * 1. Copyright Notice
   *
   * Some or all of this work - Copyright (c) 1999 - 2021, Intel Corp.
   * All rights reserved.
   *
   * 2. License
   *
   * 2.1. This is your license from Intel Corp. under its intellectual property
   * rights. You may have additional license terms from the party that provided
   * you this software, covering your right to use that party's intellectual
   * property rights.
   *
   * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
   * copy of the source code appearing in this file ("Covered Code") an
   * irrevocable, perpetual, worldwide license under Intel's copyrights in the
   * base code distributed originally by Intel ("Original Intel Code") to copy,
   * make derivatives, distribute, use and display any portion of the Covered
   * Code in any form, with the right to sublicense such rights; and
   *
   * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
   * license (with the right to sublicense), under only those claims of Intel
   * patents that are infringed by the Original Intel Code, to make, use, sell,
   * offer to sell, and import the Covered Code and derivative works thereof
   * solely to the minimum extent necessary to exercise the above copyright
   * license, and in no event shall the patent license extend to any additions
   * to or modifications of the Original Intel Code. No other license or right
   * is granted directly or by implication, estoppel or otherwise;
   *
   * The above copyright and patent license is granted only if the following
   * conditions are met:
   *
   * 3. Conditions
   *
   * 3.1. Redistribution of Source with Rights to Further Distribute Source.
   * Redistribution of source code of any substantial portion of the Covered
   * Code or modification with rights to further distribute source must include
   * the above Copyright Notice, the above License, this list of Conditions,
   * and the following Disclaimer and Export Compliance provision. In addition,
   * Licensee must cause all Covered Code to which Licensee contributes to
   * contain a file documenting the changes Licensee made to create that Covered
   * Code and the date of any change. Licensee must include in that file the
   * documentation of any changes made by any predecessor Licensee. Licensee
   * must include a prominent statement that the modification is derived,
   * directly or indirectly, from Original Intel Code.
   *
   * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
   * Redistribution of source code of any substantial portion of the Covered
   * Code or modification without rights to further distribute source must
   * include the following Disclaimer and Export Compliance provision in the
   * documentation and/or other materials provided with distribution. In
   * addition, Licensee may not authorize further sublicense of source of any
   * portion of the Covered Code, and must include terms to the effect that the
   * license from Licensee to its licensee is limited to the intellectual
   * property embodied in the software Licensee provides to its licensee, and
   * not to intellectual property embodied in modifications its licensee may
   * make.
   *
   * 3.3. Redistribution of Executable. Redistribution in executable form of any
   * substantial portion of the Covered Code or modification must reproduce the
   * above Copyright Notice, and the following Disclaimer and Export Compliance
   * provision in the documentation and/or other materials provided with the
   * distribution.
   *
   * 3.4. Intel retains all right, title, and interest in and to the Original
   * Intel Code.
   *
   * 3.5. Neither the name Intel nor any other trademark owned or controlled by
   * Intel shall be used in advertising or otherwise to promote the sale, use or
   * other dealings in products derived from or relating to the Covered Code
   * without prior written authorization from Intel.
   *
   * 4. Disclaimer and Export Compliance
   *
   * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
   * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
   * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
   * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
   * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
   * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
   * PARTICULAR PURPOSE.
   *
   * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
   * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
   * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
   * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
   * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
   * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
   * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
   * LIMITED REMEDY.
   *
   * 4.3. Licensee shall not export, either directly or indirectly, any of this
   * software or system incorporating such software without first obtaining any
   * required license or other approval from the U. S. Department of Commerce or
   * any other agency or department of the United States Government. In the
   * event Licensee exports any such software from the United States or
   * re-exports any such software from a foreign destination, Licensee shall
   * ensure that the distribution and export/re-export of the software is in
   * compliance with all laws, regulations, orders, or other restrictions of the
   * U.S. Export Administration Regulations. Licensee agrees that neither it nor
   * any of its subsidiaries will export/re-export any technical data, process,
   * software, or service, directly or indirectly, to any country for which the
   * United States government or any agency thereof requires an export license,
   * other governmental approval, or letter of assurance, without first obtaining
   * such license, approval or letter.
   *
   *****************************************************************************
   *
   * Alternatively, you may choose to be licensed under the terms of the
   * following license:
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions, and the following disclaimer,
   *    without modification.
   * 2. Redistributions in binary form must reproduce at minimum a disclaimer
   *    substantially similar to the "NO WARRANTY" disclaimer below
   *    ("Disclaimer") and any redistribution must be conditioned upon
   *    including a substantially similar Disclaimer requirement for further
   *    binary redistribution.
   * 3. Neither the names of the above-listed copyright holders nor the names
   *    of any contributors may be used to endorse or promote products derived
   *    from this software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   * Alternatively, you may choose to be licensed under the terms of the
   * GNU General Public License ("GPL") version 2 as published by the Free
   * Software Foundation.
   *
   *****************************************************************************/
  
  #include "acpibin.h"
  
  
  ACPI_TABLE_HEADER           Header1;
  ACPI_TABLE_HEADER           Header2;
  
  #define BUFFER_SIZE         256
  char                        Buffer[BUFFER_SIZE];
  
  
  /* Local prototypes */
  
  static BOOLEAN
  AbValidateHeader (
      ACPI_TABLE_HEADER       *Header);
  
  static UINT8
  AcpiTbSumTable (
      void                    *Buffer,
      UINT32                  Length);
  
  static char *
  AbGetFile (
      char                    *Filename,
      UINT32                  *FileSize);
  
  static void
  AbPrintHeaderInfo (
      ACPI_TABLE_HEADER       *Header);
  
  static void
  AbPrintHeadersInfo (
      ACPI_TABLE_HEADER       *Header,
      ACPI_TABLE_HEADER       *Header2);
  
  
  /******************************************************************************
   *
   * FUNCTION:    AbValidateHeader
   *
   * DESCRIPTION: Check for valid ACPI table header
   *
   ******************************************************************************/
  
  static BOOLEAN
  AbValidateHeader (
      ACPI_TABLE_HEADER       *Header)
  {
  
      if (!AcpiUtValidNameseg (Header->Signature))
      {
          printf ("Header signature is invalid\n");
          return (FALSE);
      }
  
      return (TRUE);
  }
  
  
  /*******************************************************************************
   *
   * FUNCTION:    AcpiTbSumTable
   *
   * PARAMETERS:  Buffer              - Buffer to checksum
   *              Length              - Size of the buffer
   *
   * RETURNS      8 bit checksum of buffer
   *
   * DESCRIPTION: Computes an 8 bit checksum of the buffer(length) and returns it.
   *
   ******************************************************************************/
  
  static UINT8
  AcpiTbSumTable (
      void                    *Buffer,
      UINT32                  Length)
  {
      const UINT8             *Limit;
      const UINT8             *Rover;
      UINT8                   Sum = 0;
  
  
      if (Buffer && Length)
      {
          /* Buffer and Length are valid */
  
          Limit = (UINT8 *) Buffer + Length;
  
          for (Rover = Buffer; Rover < Limit; Rover++)
          {
              Sum = (UINT8) (Sum + *Rover);
          }
      }
  
      return (Sum);
  }
  
  
  /*******************************************************************************
   *
   * FUNCTION:    AbPrintHeaderInfo
   *
   * PARAMETERS:  Header              - An ACPI table header
   *
   * RETURNS      None.
   *
   * DESCRIPTION: Format and display header contents.
   *
   ******************************************************************************/
  
  static void
  AbPrintHeaderInfo (
      ACPI_TABLE_HEADER       *Header)
  {
  
      /* Display header information */
  
      printf ("Signature         : %4.4s\n",    Header->Signature);
      printf ("Length            : %8.8X\n",    Header->Length);
      printf ("Revision          : %2.2X\n",    Header->Revision);
      printf ("Checksum          : %2.2X\n",    Header->Checksum);
      printf ("OEM ID            : %.6s\n",     Header->OemId);
      printf ("OEM Table ID      : %.8s\n",     Header->OemTableId);
      printf ("OEM Revision      : %8.8X\n",    Header->OemRevision);
      printf ("ASL Compiler ID   : %.4s\n",     Header->AslCompilerId);
      printf ("Compiler Revision : %8.8X\n",    Header->AslCompilerRevision);
      printf ("\n");
  }
  
  static void
  AbPrintHeadersInfo (
      ACPI_TABLE_HEADER       *Header,
      ACPI_TABLE_HEADER       *Header2)
  {
  
      /* Display header information for both headers */
  
      printf ("Signature          %8.4s : %4.4s\n",    Header->Signature, Header2->Signature);
      printf ("Length             %8.8X : %8.8X\n",    Header->Length, Header2->Length);
      printf ("Revision           %8.2X : %2.2X\n",    Header->Revision, Header2->Revision);
      printf ("Checksum           %8.2X : %2.2X\n",    Header->Checksum, Header2->Checksum);
      printf ("OEM ID             %8.6s : %.6s\n",     Header->OemId, Header2->OemId);
      printf ("OEM Table ID       %8.8s : %.8s\n",     Header->OemTableId, Header2->OemTableId);
      printf ("OEM Revision       %8.8X : %8.8X\n",    Header->OemRevision, Header2->OemRevision);
      printf ("ASL Compiler ID    %8.4s : %.4s\n",     Header->AslCompilerId, Header2->AslCompilerId);
      printf ("Compiler Revision  %8.8X : %8.8X\n",    Header->AslCompilerRevision, Header2->AslCompilerRevision);
      printf ("\n");
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AbDisplayHeader
   *
   * DESCRIPTION: Display an ACPI table header
   *
   ******************************************************************************/
  
  void
  AbDisplayHeader (
      char                    *FilePath)
  {
      UINT32                  Actual;
      FILE                    *File;
  
  
      File = fopen (FilePath, "rb");
      if (!File)
      {
          printf ("Could not open file %s\n", FilePath);
          return;
      }
  
      Actual = fread (&Header1, 1, sizeof (ACPI_TABLE_HEADER), File);
      fclose (File);
  
      if (Actual != sizeof (ACPI_TABLE_HEADER))
      {
          printf ("File %s does not contain a valid ACPI table header\n", FilePath);
          return;
      }
  
      if (!AbValidateHeader (&Header1))
      {
          return;
      }
  
      AbPrintHeaderInfo (&Header1);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AbComputeChecksum
   *
   * DESCRIPTION: Compute proper checksum for an ACPI table
   *
   ******************************************************************************/
  
  void
  AbComputeChecksum (
      char                    *FilePath)
  {
      UINT32                  Actual;
      ACPI_TABLE_HEADER       *Table;
      UINT8                   Checksum;
      FILE                    *File;
  
  
      File = fopen (FilePath, "rb");
      if (!File)
      {
          printf ("Could not open file %s\n", FilePath);
          return;
      }
  
      Actual = fread (&Header1, 1, sizeof (ACPI_TABLE_HEADER), File);
      if (Actual < sizeof (ACPI_TABLE_HEADER))
      {
          printf ("File %s does not contain a valid ACPI table header\n", FilePath);
          goto Exit1;
      }
  
      if (!AbValidateHeader (&Header1))
      {
          goto Exit1;
      }
  
      if (!Gbl_TerseMode)
      {
          AbPrintHeaderInfo (&Header1);
      }
  
      /* Allocate a buffer to hold the entire table */
  
      Table = AcpiOsAllocate (Header1.Length);
      if (!Table)
      {
          printf ("Could not allocate buffer for table\n");
          goto Exit1;
      }
  
      /* Read the entire table, including header */
  
      fseek (File, 0, SEEK_SET);
      Actual = fread (Table, 1, Header1.Length, File);
      if (Actual != Header1.Length)
      {
          printf ("Could not read table, length %u\n", Header1.Length);
          goto Exit2;
      }
  
      /* Compute the checksum for the table */
  
      Table->Checksum = 0;
  
      Checksum = (UINT8) (0 - AcpiTbSumTable (Table, Table->Length));
      printf ("Computed checksum: 0x%X\n\n", Checksum);
  
      if (Header1.Checksum == Checksum)
      {
          printf ("Checksum OK in AML file, not updating\n");
          goto Exit2;
      }
  
      /* Open the target file for writing, to update checksum */
  
      fclose (File);
      File = fopen (FilePath, "r+b");
      if (!File)
      {
          printf ("Could not open file %s for writing\n", FilePath);
          goto Exit2;
      }
  
      /* Set the checksum, write the new header */
  
      Header1.Checksum = Checksum;
  
      Actual = fwrite (&Header1, 1, sizeof (ACPI_TABLE_HEADER), File);
      if (Actual != sizeof (ACPI_TABLE_HEADER))
      {
          printf ("Could not write updated table header\n");
          goto Exit2;
      }
  
      printf ("Wrote new checksum\n");
  
  Exit2:
      AcpiOsFree (Table);
  
  Exit1:
      if (File)
      {
          fclose (File);
      }
      return;
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AbCompareAmlFiles
   *
   * DESCRIPTION: Compare two AML files
   *
   ******************************************************************************/
  
  int
  AbCompareAmlFiles (
      char                    *File1Path,
      char                    *File2Path)
  {
      UINT32                  Actual1;
      UINT32                  Actual2;
      UINT32                  Offset;
      UINT8                   Char1;
      UINT8                   Char2;
      UINT8                   Mismatches = 0;
      BOOLEAN                 HeaderMismatch = FALSE;
      FILE                    *File1;
      FILE                    *File2;
      int                     Status = -1;
  
  
      File1 = fopen (File1Path, "rb");
      if (!File1)
      {
          printf ("Could not open file %s\n", File1Path);
          return (-1);
      }
  
      File2 = fopen (File2Path, "rb");
      if (!File2)
      {
          printf ("Could not open file %s\n", File2Path);
          goto Exit1;
      }
  
      /* Read the ACPI header from each file */
  
      Actual1 = fread (&Header1, 1, sizeof (ACPI_TABLE_HEADER), File1);
      if (Actual1 != sizeof (ACPI_TABLE_HEADER))
      {
          printf ("File %s does not contain an ACPI table header\n", File1Path);
          goto Exit2;
      }
  
      Actual2 = fread (&Header2, 1, sizeof (ACPI_TABLE_HEADER), File2);
      if (Actual2 != sizeof (ACPI_TABLE_HEADER))
      {
          printf ("File %s does not contain an ACPI table header\n", File2Path);
          goto Exit2;
      }
  
      if ((!AbValidateHeader (&Header1)) ||
          (!AbValidateHeader (&Header2)))
      {
          goto Exit2;
      }
  
      /* Table signatures must match */
  
      if (*((UINT32 *) Header1.Signature) != *((UINT32 *) Header2.Signature))
      {
          printf ("Table signatures do not match\n");
          goto Exit2;
      }
  
      if (!Gbl_TerseMode)
      {
          /* Display header information */
  
          printf ("Comparing %s to %s\n", File1Path, File2Path);
          AbPrintHeadersInfo (&Header1, &Header2);
      }
  
      if (memcmp (&Header1, &Header2, sizeof (ACPI_TABLE_HEADER)))
      {
          printf ("Headers do not match exactly\n");
          HeaderMismatch = TRUE;
      }
  
      /* Do the byte-by-byte compare */
  
      printf ("Compare offset: %u\n", AbGbl_CompareOffset);
      if (AbGbl_CompareOffset)
      {
          if (fseek (File2, AbGbl_CompareOffset, SEEK_CUR))
          {
              printf ("Seek error on file %s\n", File2Path);
              goto Exit2;
          }
      }
  
      Actual1 = fread (&Char1, 1, 1, File1);
      Actual2 = fread (&Char2, 1, 1, File2);
      Offset = sizeof (ACPI_TABLE_HEADER);
  
      while ((Actual1 == 1) && (Actual2 == 1))
      {
          if (Char1 != Char2)
          {
              printf ("Error - Byte mismatch at offset %8.4X: 0x%2.2X 0x%2.2X\n",
                  Offset, Char1, Char2);
              Mismatches++;
              if ((Mismatches > 100) && (!AbGbl_DisplayAllMiscompares))
              {
                  printf ("100 Mismatches: Too many mismatches\n");
                  goto Exit2;
              }
          }
  
          Offset++;
          Actual1 = fread (&Char1, 1, 1, File1);
          Actual2 = fread (&Char2, 1, 1, File2);
      }
  
      if (Actual1)
      {
          printf ("Error - file %s is longer than file %s\n", File1Path, File2Path);
          Mismatches++;
      }
      else if (Actual2)
      {
          printf ("Error - file %s is shorter than file %s\n", File1Path, File2Path);
          Mismatches++;
      }
      else if (!Mismatches)
      {
          if (HeaderMismatch)
          {
              printf ("Files compare exactly after header\n");
          }
          else
          {
              printf ("Files compare exactly\n");
          }
      }
  
      printf ("%u Mismatches found\n", Mismatches);
      if (Mismatches == 0)
      {
          Status = 0;
      }
  
  Exit2:
      fclose (File2);
  
  Exit1:
      fclose (File1);
      return (Status);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AbGetFile
   *
   * DESCRIPTION: Open a file and read it entirely into a new buffer
   *
   ******************************************************************************/
  
  static char *
  AbGetFile (
      char                    *Filename,
      UINT32                  *FileSize)
  {
      FILE                    *File;
      UINT32                  Size;
      char                    *DataBuffer = NULL;
      size_t                  Actual;
  
  
      /* Binary mode does not alter CR/LF pairs */
  
      File = fopen (Filename, "rb");
      if (!File)
      {
          printf ("Could not open file %s\n", Filename);
          return (NULL);
      }
  
      /* Need file size to allocate a buffer */
  
      Size = CmGetFileSize (File);
      if (Size == ACPI_UINT32_MAX)
      {
          printf ("Could not get file size (seek) for %s\n", Filename);
          goto ErrorExit;
      }
  
      /* Allocate a buffer for the entire file */
  
      DataBuffer = calloc (Size, 1);
      if (!DataBuffer)
      {
          printf ("Could not allocate buffer of size %u\n", Size);
          goto ErrorExit;
      }
  
      /* Read the entire file */
  
      Actual = fread (DataBuffer, 1, Size, File);
      if (Actual != Size)
      {
          printf ("Could not read the input file %s\n", Filename);
          free (DataBuffer);
          DataBuffer = NULL;
          goto ErrorExit;
      }
  
      *FileSize = Size;
  
  ErrorExit:
      fclose (File);
      return (DataBuffer);
  }
  
  
  /******************************************************************************
   *
   * FUNCTION:    AbDumpAmlFile
   *
   * DESCRIPTION: Dump a binary AML file to a text file
   *
   ******************************************************************************/
  
  int
  AbDumpAmlFile (
      char                    *File1Path,
      char                    *File2Path)
  {
      char                    *FileBuffer;
      FILE                    *FileOutHandle;
      UINT32                  FileSize = 0;
      int                     Status = -1;
  
  
      /* Get the entire AML file, validate header */
  
      FileBuffer = AbGetFile (File1Path, &FileSize);
      if (!FileBuffer)
      {
          return (-1);
      }
  
      printf ("Input file:  %s contains %u (0x%X) bytes\n",
          File1Path, FileSize, FileSize);
  
      FileOutHandle = fopen (File2Path, "wb");
      if (!FileOutHandle)
      {
          printf ("Could not open file %s\n", File2Path);
          goto Exit1;
      }
  
      if (!AbValidateHeader ((ACPI_TABLE_HEADER *) FileBuffer))
      {
          goto Exit2;
      }
  
      /* Convert binary AML to text, using common dump buffer routine */
  
      AcpiGbl_DebugFile = FileOutHandle;
      AcpiGbl_DbOutputFlags = ACPI_DB_REDIRECTABLE_OUTPUT;
  
      AcpiOsPrintf ("%4.4s @ 0x%8.8X\n",
          ((ACPI_TABLE_HEADER *) FileBuffer)->Signature, 0);
  
      AcpiUtDumpBuffer ((UINT8 *) FileBuffer, FileSize, DB_BYTE_DISPLAY, 0);
  
      /* Summary for the output file */
  
      FileSize = CmGetFileSize (FileOutHandle);
      printf ("Output file: %s contains %u (0x%X) bytes\n\n",
          File2Path, FileSize, FileSize);
  
      Status = 0;
  
  Exit2:
      fclose (FileOutHandle);
  
  Exit1:
      free (FileBuffer);
      return (Status);
  }
  