// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/******************************************************************************
 *
 * Module Name: nsprepkg - Validation of package objects for predefined names
 *
 * Copyright (C) 2000 - 2025, Intel Corp.
 *
 *****************************************************************************/

#include <acpi/acpi.h>
#include "accommon.h"
#include "acnamesp.h"
#include "acpredef.h"

#define _COMPONENT          ACPI_NAMESPACE
ACPI_MODULE_NAME("nsprepkg")

/* Local prototypes */
static acpi_status
acpi_ns_check_package_list(struct acpi_evaluate_info *info,
                           const union acpi_predefined_info *package,
                           union acpi_operand_object **elements, u32 count);

static acpi_status
acpi_ns_check_package_elements(struct acpi_evaluate_info *info,
                               union acpi_operand_object **elements,
                               u8 type1,
                               u32 count1,
                               u8 type2, u32 count2, u32 start_index);

static acpi_status
acpi_ns_custom_package(struct acpi_evaluate_info *info,
                       union acpi_operand_object **elements, u32 count);

/*******************************************************************************
 *
 * FUNCTION:    acpi_ns_check_package
 *
 * PARAMETERS:  info                - Method execution information block
 *              return_object_ptr   - Pointer to the object returned from the
 *                                    evaluation of a method or object
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Check a returned package object for the correct count and
 *              correct type of all sub-objects.
 *
 ******************************************************************************/

acpi_status
acpi_ns_check_package(struct acpi_evaluate_info *info,
                      union acpi_operand_object **return_object_ptr)
{
        union acpi_operand_object *return_object = *return_object_ptr;
        const union acpi_predefined_info *package;
        union acpi_operand_object **elements;
        acpi_status status = AE_OK;
        u32 expected_count;
        u32 count;
        u32 i;

        ACPI_FUNCTION_TRACE(ns_check_package);

        /* The package info for this name is in the next table entry */

        package = info->predefined + 1;

        ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
                          "%s Validating return Package of Type %X, Count %X\n",
                          info->full_pathname, package->ret_info.type,
                          return_object->package.count));

        /*
         * For variable-length Packages, we can safely remove all embedded
         * and trailing NULL package elements
         */
        acpi_ns_remove_null_elements(info, package->ret_info.type,
                                     return_object);

        /* Extract package count and elements array */

        elements = return_object->package.elements;
        count = return_object->package.count;

        /*
         * Most packages must have at least one element. The only exception
         * is the variable-length package (ACPI_PTYPE1_VAR).
         */
        if (!count) {
                if (package->ret_info.type == ACPI_PTYPE1_VAR) {
                        return_ACPI_STATUS(AE_OK);
                }

                ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
                                      info->node_flags,
                                      "Return Package has no elements (empty)"));

                return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
        }

        /*
         * Decode the type of the expected package contents
         *
         * PTYPE1 packages contain no subpackages
         * PTYPE2 packages contain subpackages
         */
        switch (package->ret_info.type) {
        case ACPI_PTYPE_CUSTOM:

                status = acpi_ns_custom_package(info, elements, count);
                break;

        case ACPI_PTYPE1_FIXED:
                /*
                 * The package count is fixed and there are no subpackages
                 *
                 * If package is too small, exit.
                 * If package is larger than expected, issue warning but continue
                 */
                expected_count =
                    package->ret_info.count1 + package->ret_info.count2;
                if (count < expected_count) {
                        goto package_too_small;
                } else if (count > expected_count) {
                        ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
                                          "%s: Return Package is larger than needed - "
                                          "found %u, expected %u\n",
                                          info->full_pathname, count,
                                          expected_count));
                }

                /* Validate all elements of the returned package */

                status = acpi_ns_check_package_elements(info, elements,
                                                        package->ret_info.
                                                        object_type1,
                                                        package->ret_info.
                                                        count1,
                                                        package->ret_info.
                                                        object_type2,
                                                        package->ret_info.
                                                        count2, 0);
                break;

        case ACPI_PTYPE1_VAR:
                /*
                 * The package count is variable, there are no subpackages, and all
                 * elements must be of the same type
                 */
                for (i = 0; i < count; i++) {
                        status = acpi_ns_check_object_type(info, elements,
                                                           package->ret_info.
                                                           object_type1, i);
                        if (ACPI_FAILURE(status)) {
                                return_ACPI_STATUS(status);
                        }

                        elements++;
                }
                break;

        case ACPI_PTYPE1_OPTION:
                /*
                 * The package count is variable, there are no subpackages. There are
                 * a fixed number of required elements, and a variable number of
                 * optional elements.
                 *
                 * Check if package is at least as large as the minimum required
                 */
                expected_count = package->ret_info3.count;
                if (count < expected_count) {
                        goto package_too_small;
                }

                /* Variable number of sub-objects */

                for (i = 0; i < count; i++) {
                        if (i < package->ret_info3.count) {

                                /* These are the required package elements (0, 1, or 2) */

                                status =
                                    acpi_ns_check_object_type(info, elements,
                                                              package->
                                                              ret_info3.
                                                              object_type[i],
                                                              i);
                                if (ACPI_FAILURE(status)) {
                                        return_ACPI_STATUS(status);
                                }
                        } else {
                                /* These are the optional package elements */

                                status =
                                    acpi_ns_check_object_type(info, elements,
                                                              package->
                                                              ret_info3.
                                                              tail_object_type,
                                                              i);
                                if (ACPI_FAILURE(status)) {
                                        return_ACPI_STATUS(status);
                                }
                        }

                        elements++;
                }
                break;

        case ACPI_PTYPE2_REV_FIXED:

                /* First element is the (Integer) revision */

                status =
                    acpi_ns_check_object_type(info, elements,
                                              ACPI_RTYPE_INTEGER, 0);
                if (ACPI_FAILURE(status)) {
                        return_ACPI_STATUS(status);
                }

                elements++;
                count--;

                /* Examine the subpackages */

                status =
                    acpi_ns_check_package_list(info, package, elements, count);
                break;

        case ACPI_PTYPE2_PKG_COUNT:

                /* First element is the (Integer) count of subpackages to follow */

                status =
                    acpi_ns_check_object_type(info, elements,
                                              ACPI_RTYPE_INTEGER, 0);
                if (ACPI_FAILURE(status)) {
                        return_ACPI_STATUS(status);
                }

                /*
                 * Count cannot be larger than the parent package length, but allow it
                 * to be smaller. The >= accounts for the Integer above.
                 */
                expected_count = (u32)(*elements)->integer.value;
                if (expected_count >= count) {
                        goto package_too_small;
                }

                count = expected_count;
                elements++;

                /* Examine the subpackages */

                status =
                    acpi_ns_check_package_list(info, package, elements, count);
                break;

        case ACPI_PTYPE2:
        case ACPI_PTYPE2_FIXED:
        case ACPI_PTYPE2_MIN:
        case ACPI_PTYPE2_COUNT:
        case ACPI_PTYPE2_FIX_VAR:
                /*
                 * These types all return a single Package that consists of a
                 * variable number of subpackages.
                 *
                 * First, ensure that the first element is a subpackage. If not,
                 * the BIOS may have incorrectly returned the object as a single
                 * package instead of a Package of Packages (a common error if
                 * there is only one entry). We may be able to repair this by
                 * wrapping the returned Package with a new outer Package.
                 */
                if (*elements
                    && ((*elements)->common.type != ACPI_TYPE_PACKAGE)) {

                        /* Create the new outer package and populate it */

                        status =
                            acpi_ns_wrap_with_package(info, return_object,
                                                      return_object_ptr);
                        if (ACPI_FAILURE(status)) {
                                return_ACPI_STATUS(status);
                        }

                        /* Update locals to point to the new package (of 1 element) */

                        return_object = *return_object_ptr;
                        elements = return_object->package.elements;
                        count = 1;
                }

                /* Examine the subpackages */

                status =
                    acpi_ns_check_package_list(info, package, elements, count);
                break;

        case ACPI_PTYPE2_VAR_VAR:
                /*
                 * Returns a variable list of packages, each with a variable list
                 * of objects.
                 */
                break;

        case ACPI_PTYPE2_UUID_PAIR:

                /* The package must contain pairs of (UUID + type) */

                if (count & 1) {
                        expected_count = count + 1;
                        goto package_too_small;
                }

                while (count > 0) {
                        status = acpi_ns_check_object_type(info, elements,
                                                           package->ret_info.
                                                           object_type1, 0);
                        if (ACPI_FAILURE(status)) {
                                return_ACPI_STATUS(status);
                        }

                        /* Validate length of the UUID buffer */

                        if ((*elements)->buffer.length != 16) {
                                ACPI_WARN_PREDEFINED((AE_INFO,
                                                      info->full_pathname,
                                                      info->node_flags,
                                                      "Invalid length for UUID Buffer"));
                                return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
                        }

                        status = acpi_ns_check_object_type(info, elements + 1,
                                                           package->ret_info.
                                                           object_type2, 0);
                        if (ACPI_FAILURE(status)) {
                                return_ACPI_STATUS(status);
                        }

                        elements += 2;
                        count -= 2;
                }
                break;

        default:

                /* Should not get here if predefined info table is correct */

                ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
                                      info->node_flags,
                                      "Invalid internal return type in table entry: %X",
                                      package->ret_info.type));

                return_ACPI_STATUS(AE_AML_INTERNAL);
        }

        return_ACPI_STATUS(status);

package_too_small:

        /* Error exit for the case with an incorrect package count */

        ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname, info->node_flags,
                              "Return Package is too small - found %u elements, expected %u",
                              count, expected_count));

        return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ns_check_package_list
 *
 * PARAMETERS:  info            - Method execution information block
 *              package         - Pointer to package-specific info for method
 *              elements        - Element list of parent package. All elements
 *                                of this list should be of type Package.
 *              count           - Count of subpackages
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Examine a list of subpackages
 *
 ******************************************************************************/

static acpi_status
acpi_ns_check_package_list(struct acpi_evaluate_info *info,
                           const union acpi_predefined_info *package,
                           union acpi_operand_object **elements, u32 count)
{
        union acpi_operand_object *sub_package;
        union acpi_operand_object **sub_elements;
        acpi_status status;
        u32 expected_count;
        u32 i;
        u32 j;

        /*
         * Validate each subpackage in the parent Package
         *
         * NOTE: assumes list of subpackages contains no NULL elements.
         * Any NULL elements should have been removed by earlier call
         * to acpi_ns_remove_null_elements.
         */
        for (i = 0; i < count; i++) {
                sub_package = *elements;
                sub_elements = sub_package->package.elements;
                info->parent_package = sub_package;

                /* Each sub-object must be of type Package */

                status = acpi_ns_check_object_type(info, &sub_package,
                                                   ACPI_RTYPE_PACKAGE, i);
                if (ACPI_FAILURE(status)) {
                        return (status);
                }

                /* Examine the different types of expected subpackages */

                info->parent_package = sub_package;
                switch (package->ret_info.type) {
                case ACPI_PTYPE2:
                case ACPI_PTYPE2_PKG_COUNT:
                case ACPI_PTYPE2_REV_FIXED:

                        /* Each subpackage has a fixed number of elements */

                        expected_count =
                            package->ret_info.count1 + package->ret_info.count2;
                        if (sub_package->package.count < expected_count) {
                                goto package_too_small;
                        }

                        status =
                            acpi_ns_check_package_elements(info, sub_elements,
                                                           package->ret_info.
                                                           object_type1,
                                                           package->ret_info.
                                                           count1,
                                                           package->ret_info.
                                                           object_type2,
                                                           package->ret_info.
                                                           count2, 0);
                        if (ACPI_FAILURE(status)) {
                                return (status);
                        }
                        break;

                case ACPI_PTYPE2_FIX_VAR:
                        /*
                         * Each subpackage has a fixed number of elements and an
                         * optional element
                         */
                        expected_count =
                            package->ret_info.count1 + package->ret_info.count2;
                        if (sub_package->package.count < expected_count) {
                                goto package_too_small;
                        }

                        status =
                            acpi_ns_check_package_elements(info, sub_elements,
                                                           package->ret_info.
                                                           object_type1,
                                                           package->ret_info.
                                                           count1,
                                                           package->ret_info.
                                                           object_type2,
                                                           sub_package->package.
                                                           count -
                                                           package->ret_info.
                                                           count1, 0);
                        if (ACPI_FAILURE(status)) {
                                return (status);
                        }
                        break;

                case ACPI_PTYPE2_VAR_VAR:
                        /*
                         * Each subpackage has a fixed or variable number of elements
                         */
                        break;

                case ACPI_PTYPE2_FIXED:

                        /* Each subpackage has a fixed length */

                        expected_count = package->ret_info2.count;
                        if (sub_package->package.count < expected_count) {
                                goto package_too_small;
                        }

                        /* Check the type of each subpackage element */

                        for (j = 0; j < expected_count; j++) {
                                status =
                                    acpi_ns_check_object_type(info,
                                                              &sub_elements[j],
                                                              package->
                                                              ret_info2.
                                                              object_type[j],
                                                              j);
                                if (ACPI_FAILURE(status)) {
                                        return (status);
                                }
                        }
                        break;

                case ACPI_PTYPE2_MIN:

                        /* Each subpackage has a variable but minimum length */

                        expected_count = package->ret_info.count1;
                        if (sub_package->package.count < expected_count) {
                                goto package_too_small;
                        }

                        /* Check the type of each subpackage element */

                        status =
                            acpi_ns_check_package_elements(info, sub_elements,
                                                           package->ret_info.
                                                           object_type1,
                                                           sub_package->package.
                                                           count, 0, 0, 0);
                        if (ACPI_FAILURE(status)) {
                                return (status);
                        }
                        break;

                case ACPI_PTYPE2_COUNT:
                        /*
                         * First element is the (Integer) count of elements, including
                         * the count field (the ACPI name is num_elements)
                         */
                        status = acpi_ns_check_object_type(info, sub_elements,
                                                           ACPI_RTYPE_INTEGER,
                                                           0);
                        if (ACPI_FAILURE(status)) {
                                return (status);
                        }

                        /*
                         * Make sure package is large enough for the Count and is
                         * is as large as the minimum size
                         */
                        expected_count = (u32)(*sub_elements)->integer.value;
                        if (sub_package->package.count < expected_count) {
                                goto package_too_small;
                        }

                        if (sub_package->package.count <
                            package->ret_info.count1) {
                                expected_count = package->ret_info.count1;
                                goto package_too_small;
                        }

                        if (expected_count == 0) {
                                /*
                                 * Either the num_entries element was originally zero or it was
                                 * a NULL element and repaired to an Integer of value zero.
                                 * In either case, repair it by setting num_entries to be the
                                 * actual size of the subpackage.
                                 */
                                expected_count = sub_package->package.count;
                                (*sub_elements)->integer.value = expected_count;
                        }

                        /* Check the type of each subpackage element */

                        status =
                            acpi_ns_check_package_elements(info,
                                                           (sub_elements + 1),
                                                           package->ret_info.
                                                           object_type1,
                                                           (expected_count - 1),
                                                           0, 0, 1);
                        if (ACPI_FAILURE(status)) {
                                return (status);
                        }
                        break;

                default:        /* Should not get here, type was validated by caller */

                        ACPI_ERROR((AE_INFO, "Invalid Package type: %X",
                                    package->ret_info.type));
                        return (AE_AML_INTERNAL);
                }

                elements++;
        }

        return (AE_OK);

package_too_small:

        /* The subpackage count was smaller than required */

        ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname, info->node_flags,
                              "Return SubPackage[%u] is too small - found %u elements, expected %u",
                              i, sub_package->package.count, expected_count));

        return (AE_AML_OPERAND_VALUE);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ns_custom_package
 *
 * PARAMETERS:  info                - Method execution information block
 *              elements            - Pointer to the package elements array
 *              count               - Element count for the package
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Check a returned package object for the correct count and
 *              correct type of all sub-objects.
 *
 * NOTE: Currently used for the _BIX method only. When needed for two or more
 * methods, probably a detect/dispatch mechanism will be required.
 *
 ******************************************************************************/

static acpi_status
acpi_ns_custom_package(struct acpi_evaluate_info *info,
                       union acpi_operand_object **elements, u32 count)
{
        u32 expected_count;
        u32 version;
        acpi_status status = AE_OK;

        ACPI_FUNCTION_NAME(ns_custom_package);

        /* Get version number, must be Integer */

        if ((*elements)->common.type != ACPI_TYPE_INTEGER) {
                ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
                                      info->node_flags,
                                      "Return Package has invalid object type for version number"));
                return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
        }

        version = (u32)(*elements)->integer.value;
        expected_count = 21;    /* Version 1 */

        if (version == 0) {
                expected_count = 20;    /* Version 0 */
        }

        if (count < expected_count) {
                ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
                                      info->node_flags,
                                      "Return Package is too small - found %u elements, expected %u",
                                      count, expected_count));
                return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
        } else if (count > expected_count) {
                ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
                                  "%s: Return Package is larger than needed - "
                                  "found %u, expected %u\n",
                                  info->full_pathname, count, expected_count));
        }

        /* Validate all elements of the returned package */

        status = acpi_ns_check_package_elements(info, elements,
                                                ACPI_RTYPE_INTEGER, 16,
                                                ACPI_RTYPE_STRING, 4, 0);
        if (ACPI_FAILURE(status)) {
                return_ACPI_STATUS(status);
        }

        /* Version 1 has a single trailing integer */

        if (version > 0) {
                status = acpi_ns_check_package_elements(info, elements + 20,
                                                        ACPI_RTYPE_INTEGER, 1,
                                                        0, 0, 20);
        }

        return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ns_check_package_elements
 *
 * PARAMETERS:  info            - Method execution information block
 *              elements        - Pointer to the package elements array
 *              type1           - Object type for first group
 *              count1          - Count for first group
 *              type2           - Object type for second group
 *              count2          - Count for second group
 *              start_index     - Start of the first group of elements
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Check that all elements of a package are of the correct object
 *              type. Supports up to two groups of different object types.
 *
 ******************************************************************************/

static acpi_status
acpi_ns_check_package_elements(struct acpi_evaluate_info *info,
                               union acpi_operand_object **elements,
                               u8 type1,
                               u32 count1,
                               u8 type2, u32 count2, u32 start_index)
{
        union acpi_operand_object **this_element = elements;
        acpi_status status;
        u32 i;

        ACPI_FUNCTION_TRACE(ns_check_package_elements);

        /*
         * Up to two groups of package elements are supported by the data
         * structure. All elements in each group must be of the same type.
         * The second group can have a count of zero.
         */
        for (i = 0; i < count1; i++) {
                status = acpi_ns_check_object_type(info, this_element,
                                                   type1, i + start_index);
                if (ACPI_FAILURE(status)) {
                        return_ACPI_STATUS(status);
                }

                this_element++;
        }

        for (i = 0; i < count2; i++) {
                status = acpi_ns_check_object_type(info, this_element,
                                                   type2,
                                                   (i + count1 + start_index));
                if (ACPI_FAILURE(status)) {
                        return_ACPI_STATUS(status);
                }

                this_element++;
        }

        return_ACPI_STATUS(AE_OK);
}