[mirror_edk2.git] / MdeModulePkg / Library / VarCheckPolicyLib / VarCheckPolicyLib.c

/** @file -- VarCheckPolicyLib.c\r
This is a NULL library instance that leverages the VarCheck interface\r
and the business logic behind the VariablePolicy code to make its decisions.\r
\r
Copyright (c) Microsoft Corporation.\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <Library/VarCheckLib.h>\r
#include <Library/BaseLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/SafeIntLib.h>\r
#include <Library/MmServicesTableLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
\r
#include <Protocol/MmCommunication.h>\r
\r
#include <Protocol/VariablePolicy.h>\r
#include <Library/VariablePolicyLib.h>\r
\r
#include <Guid/VarCheckPolicyMmi.h>\r
\r
#include "VarCheckPolicyLib.h"\r
\r
//================================================\r
// As a VarCheck library, we're linked into the VariableServices\r
// and may not be able to call them indirectly. To get around this,\r
// use the internal GetVariable function to query the variable store.\r
//================================================\r
EFI_STATUS\r
EFIAPI\r
VariableServiceGetVariable (\r
  IN      CHAR16            *VariableName,\r
  IN      EFI_GUID          *VendorGuid,\r
  OUT     UINT32            *Attributes OPTIONAL,\r
  IN OUT  UINTN             *DataSize,\r
  OUT     VOID              *Data\r
  );\r
\r
\r
UINT8     mSecurityEvalBuffer[VAR_CHECK_POLICY_MM_COMM_BUFFER_SIZE];\r
\r
// Pagination Cache Variables\r
UINT8       *mPaginationCache = NULL;\r
UINTN       mPaginationCacheSize = 0;\r
UINT32      mCurrentPaginationCommand = 0;\r
\r
\r
/**\r
  MM Communication Handler to recieve commands from the DXE protocol for\r
  Variable Policies. This communication channel is used to register new policies\r
  and poll and toggle the enforcement of variable policies.\r
\r
  @param[in]      DispatchHandle      All parameters standard to MM communications convention.\r
  @param[in]      RegisterContext     All parameters standard to MM communications convention.\r
  @param[in,out]  CommBuffer          All parameters standard to MM communications convention.\r
  @param[in,out]  CommBufferSize      All parameters standard to MM communications convention.\r
\r
  @retval     EFI_SUCCESS\r
  @retval     EFI_INVALID_PARAMETER   CommBuffer or CommBufferSize is null pointer.\r
  @retval     EFI_INVALID_PARAMETER   CommBuffer size is wrong.\r
  @retval     EFI_INVALID_PARAMETER   Revision or signature don't match.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
VarCheckPolicyLibMmiHandler (\r
  IN     EFI_HANDLE                   DispatchHandle,\r
  IN     CONST VOID                   *RegisterContext,\r
  IN OUT VOID                         *CommBuffer,\r
  IN OUT UINTN                        *CommBufferSize\r
  )\r
{\r
  UINTN                                     InternalCommBufferSize;\r
  VOID                                      *InternalCommBuffer;\r
  EFI_STATUS                                Status;\r
  EFI_STATUS                                SubCommandStatus;\r
  VAR_CHECK_POLICY_COMM_HEADER              *PolicyCommmHeader;\r
  VAR_CHECK_POLICY_COMM_HEADER              *InternalPolicyCommmHeader;\r
  VAR_CHECK_POLICY_COMM_IS_ENABLED_PARAMS   *IsEnabledParams;\r
  VAR_CHECK_POLICY_COMM_DUMP_PARAMS         *DumpParamsIn;\r
  VAR_CHECK_POLICY_COMM_DUMP_PARAMS         *DumpParamsOut;\r
  UINT8                                     *DumpInputBuffer;\r
  UINT8                                     *DumpOutputBuffer;\r
  UINTN                                     DumpTotalPages;\r
  VARIABLE_POLICY_ENTRY                     *PolicyEntry;\r
  UINTN                                     ExpectedSize;\r
  UINT32                                    TempSize;\r
\r
  Status = EFI_SUCCESS;\r
\r
  //\r
  // Validate some input parameters.\r
  //\r
  // If either of the pointers are NULL, we can't proceed.\r
  if (CommBuffer == NULL || CommBufferSize == NULL) {\r
    DEBUG(( DEBUG_INFO, "%a - Invalid comm buffer pointers!\n", __FUNCTION__ ));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  // Make sure that the buffer does not overlap SMM.\r
  // This should be covered by the SmiManage infrastructure, but just to be safe...\r
  InternalCommBufferSize = *CommBufferSize;\r
  if (InternalCommBufferSize > VAR_CHECK_POLICY_MM_COMM_BUFFER_SIZE ||\r
      !VarCheckPolicyIsBufferOutsideValid((UINTN)CommBuffer, (UINT64)InternalCommBufferSize)) {\r
    DEBUG ((DEBUG_ERROR, "%a - Invalid CommBuffer supplied! 0x%016lX[0x%016lX]\n", __FUNCTION__, CommBuffer, InternalCommBufferSize));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  // If the size does not meet a minimum threshold, we cannot proceed.\r
  ExpectedSize = sizeof(VAR_CHECK_POLICY_COMM_HEADER);\r
  if (InternalCommBufferSize < ExpectedSize) {\r
    DEBUG(( DEBUG_INFO, "%a - Bad comm buffer size! %d < %d\n", __FUNCTION__, InternalCommBufferSize, ExpectedSize ));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Before proceeding any further, copy the buffer internally so that we can compare\r
  // without worrying about TOCTOU.\r
  //\r
  InternalCommBuffer = &mSecurityEvalBuffer[0];\r
  CopyMem(InternalCommBuffer, CommBuffer, InternalCommBufferSize);\r
  PolicyCommmHeader = CommBuffer;\r
  InternalPolicyCommmHeader = InternalCommBuffer;\r
  // Check the revision and the signature of the comm header.\r
  if (InternalPolicyCommmHeader->Signature != VAR_CHECK_POLICY_COMM_SIG ||\r
      InternalPolicyCommmHeader->Revision != VAR_CHECK_POLICY_COMM_REVISION) {\r
    DEBUG(( DEBUG_INFO, "%a - Signature or revision are incorrect!\n", __FUNCTION__ ));\r
    // We have verified the buffer is not null and have enough size to hold Result field.\r
    PolicyCommmHeader->Result = EFI_INVALID_PARAMETER;\r
    return EFI_SUCCESS;\r
  }\r
\r
  // If we're in the middle of a paginated dump and any other command is sent,\r
  // pagination cache must be cleared.\r
  if (mPaginationCache != NULL && InternalPolicyCommmHeader->Command != mCurrentPaginationCommand) {\r
    FreePool (mPaginationCache);\r
    mPaginationCache = NULL;\r
    mPaginationCacheSize = 0;\r
    mCurrentPaginationCommand = 0;\r
  }\r
\r
  //\r
  // Now we can process the command as it was sent.\r
  //\r
  PolicyCommmHeader->Result = EFI_ABORTED;    // Set a default return for incomplete commands.\r
  switch(InternalPolicyCommmHeader->Command) {\r
    case VAR_CHECK_POLICY_COMMAND_DISABLE:\r
      PolicyCommmHeader->Result = DisableVariablePolicy();\r
      break;\r
\r
    case VAR_CHECK_POLICY_COMMAND_IS_ENABLED:\r
      // Make sure that we're dealing with a reasonable size.\r
      // This add should be safe because these are fixed sizes so far.\r
      ExpectedSize += sizeof(VAR_CHECK_POLICY_COMM_IS_ENABLED_PARAMS);\r
      if (InternalCommBufferSize < ExpectedSize) {\r
        DEBUG(( DEBUG_INFO, "%a - Bad comm buffer size! %d < %d\n", __FUNCTION__, InternalCommBufferSize, ExpectedSize ));\r
        PolicyCommmHeader->Result = EFI_INVALID_PARAMETER;\r
        break;\r
      }\r
\r
      // Now that we know we've got a valid size, we can fill in the rest of the data.\r
      IsEnabledParams = (VAR_CHECK_POLICY_COMM_IS_ENABLED_PARAMS*)((UINT8*)CommBuffer + sizeof(VAR_CHECK_POLICY_COMM_HEADER));\r
      IsEnabledParams->State = IsVariablePolicyEnabled();\r
      PolicyCommmHeader->Result = EFI_SUCCESS;\r
      break;\r
\r
    case VAR_CHECK_POLICY_COMMAND_REGISTER:\r
      // Make sure that we're dealing with a reasonable size.\r
      // This add should be safe because these are fixed sizes so far.\r
      ExpectedSize += sizeof(VARIABLE_POLICY_ENTRY);\r
      if (InternalCommBufferSize < ExpectedSize) {\r
        DEBUG(( DEBUG_INFO, "%a - Bad comm buffer size! %d < %d\n", __FUNCTION__, InternalCommBufferSize, ExpectedSize ));\r
        PolicyCommmHeader->Result = EFI_INVALID_PARAMETER;\r
        break;\r
      }\r
\r
      // At the very least, we can assume that we're working with a valid policy entry.\r
      // Time to compare its internal size.\r
      PolicyEntry = (VARIABLE_POLICY_ENTRY*)((UINT8*)InternalCommBuffer + sizeof(VAR_CHECK_POLICY_COMM_HEADER));\r
      if (PolicyEntry->Version != VARIABLE_POLICY_ENTRY_REVISION ||\r
          PolicyEntry->Size < sizeof(VARIABLE_POLICY_ENTRY) ||\r
          EFI_ERROR(SafeUintnAdd(sizeof(VAR_CHECK_POLICY_COMM_HEADER), PolicyEntry->Size, &ExpectedSize)) ||\r
          InternalCommBufferSize < ExpectedSize) {\r
        DEBUG(( DEBUG_INFO, "%a - Bad policy entry contents!\n", __FUNCTION__ ));\r
        PolicyCommmHeader->Result = EFI_INVALID_PARAMETER;\r
        break;\r
      }\r
\r
      PolicyCommmHeader->Result = RegisterVariablePolicy( PolicyEntry );\r
      break;\r
\r
    case VAR_CHECK_POLICY_COMMAND_DUMP:\r
      // Make sure that we're dealing with a reasonable size.\r
      // This add should be safe because these are fixed sizes so far.\r
      ExpectedSize += sizeof(VAR_CHECK_POLICY_COMM_DUMP_PARAMS) + VAR_CHECK_POLICY_MM_DUMP_BUFFER_SIZE;\r
      if (InternalCommBufferSize < ExpectedSize) {\r
        DEBUG(( DEBUG_INFO, "%a - Bad comm buffer size! %d < %d\n", __FUNCTION__, InternalCommBufferSize, ExpectedSize ));\r
        PolicyCommmHeader->Result = EFI_INVALID_PARAMETER;\r
        break;\r
      }\r
\r
      // Now that we know we've got a valid size, we can fill in the rest of the data.\r
      DumpParamsIn = (VAR_CHECK_POLICY_COMM_DUMP_PARAMS*)(InternalPolicyCommmHeader + 1);\r
      DumpParamsOut = (VAR_CHECK_POLICY_COMM_DUMP_PARAMS*)(PolicyCommmHeader + 1);\r
\r
      // If we're requesting the first page, initialize the cache and get the sizes.\r
      if (DumpParamsIn->PageRequested == 0) {\r
        if (mPaginationCache != NULL) {\r
          FreePool (mPaginationCache);\r
          mPaginationCache = NULL;\r
        }\r
\r
        // Determine what the required size is going to be.\r
        DumpParamsOut->TotalSize = 0;\r
        DumpParamsOut->PageSize = 0;\r
        DumpParamsOut->HasMore = FALSE;\r
        TempSize = 0;\r
        SubCommandStatus = DumpVariablePolicy (NULL, &TempSize);\r
        if (SubCommandStatus == EFI_BUFFER_TOO_SMALL && TempSize > 0) {\r
          mCurrentPaginationCommand = VAR_CHECK_POLICY_COMMAND_DUMP;\r
          mPaginationCacheSize = TempSize;\r
          DumpParamsOut->TotalSize = TempSize;\r
          mPaginationCache = AllocatePool (mPaginationCacheSize);\r
          if (mPaginationCache == NULL) {\r
            SubCommandStatus = EFI_OUT_OF_RESOURCES;\r
          }\r
        }\r
\r
        // If we've allocated our pagination cache, we're good to cache.\r
        if (mPaginationCache != NULL) {\r
          SubCommandStatus = DumpVariablePolicy (mPaginationCache, &TempSize);\r
        }\r
\r
        // Populate the remaining fields and we can boogie.\r
        if (!EFI_ERROR (SubCommandStatus) && mPaginationCache != NULL) {\r
          DumpParamsOut->HasMore = TRUE;\r
        }\r
      } else if (mPaginationCache != NULL) {\r
        DumpParamsOut->TotalSize = (UINT32)mPaginationCacheSize;\r
        DumpOutputBuffer = (UINT8*)(DumpParamsOut + 1);\r
\r
        // Make sure that we don't over-index the cache.\r
        DumpTotalPages = mPaginationCacheSize / VAR_CHECK_POLICY_MM_DUMP_BUFFER_SIZE;\r
        if (mPaginationCacheSize % VAR_CHECK_POLICY_MM_DUMP_BUFFER_SIZE != 0) {\r
          DumpTotalPages++;\r
        }\r
        if (DumpParamsIn->PageRequested > DumpTotalPages) {\r
          SubCommandStatus = EFI_INVALID_PARAMETER;\r
        } else {\r
          // Figure out how far into the page cache we need to go for our next page.\r
          // We know the blind subtraction won't be bad because we already checked for page 0.\r
          DumpInputBuffer = &mPaginationCache[VAR_CHECK_POLICY_MM_DUMP_BUFFER_SIZE * (DumpParamsIn->PageRequested - 1)];\r
          TempSize = VAR_CHECK_POLICY_MM_DUMP_BUFFER_SIZE;\r
          // If we're getting the last page, adjust the PageSize.\r
          if (DumpParamsIn->PageRequested == DumpTotalPages) {\r
            TempSize = mPaginationCacheSize % VAR_CHECK_POLICY_MM_DUMP_BUFFER_SIZE;\r
          }\r
          CopyMem (DumpOutputBuffer, DumpInputBuffer, TempSize);\r
          DumpParamsOut->PageSize = TempSize;\r
          // If we just got the last page, settle up the cache.\r
          if (DumpParamsIn->PageRequested == DumpTotalPages) {\r
            DumpParamsOut->HasMore = FALSE;\r
            FreePool (mPaginationCache);\r
            mPaginationCache = NULL;\r
            mPaginationCacheSize = 0;\r
            mCurrentPaginationCommand = 0;\r
          // Otherwise, we could do more here.\r
          } else {\r
            DumpParamsOut->HasMore = TRUE;\r
          }\r
\r
          // If we made it this far, we're basically good.\r
          SubCommandStatus = EFI_SUCCESS;\r
        }\r
      // If we've requested any other page than 0 and the cache is empty, we must have timed out.\r
      } else {\r
        DumpParamsOut->TotalSize = 0;\r
        DumpParamsOut->PageSize = 0;\r
        DumpParamsOut->HasMore = FALSE;\r
        SubCommandStatus = EFI_TIMEOUT;\r
      }\r
\r
      // There's currently no use for this, but it shouldn't be hard to implement.\r
      PolicyCommmHeader->Result = SubCommandStatus;\r
      break;\r
\r
    case VAR_CHECK_POLICY_COMMAND_LOCK:\r
      PolicyCommmHeader->Result = LockVariablePolicy();\r
      break;\r
\r
    default:\r
      // Mark unknown requested command as EFI_UNSUPPORTED.\r
      DEBUG(( DEBUG_INFO, "%a - Invalid command requested! %d\n", __FUNCTION__, PolicyCommmHeader->Command ));\r
      PolicyCommmHeader->Result = EFI_UNSUPPORTED;\r
      break;\r
  }\r
\r
  DEBUG(( DEBUG_VERBOSE, "%a - Command %d returning %r.\n", __FUNCTION__,\r
          PolicyCommmHeader->Command, PolicyCommmHeader->Result ));\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Constructor function of VarCheckPolicyLib to register VarCheck handler and\r
  SW MMI handlers.\r
\r
  @retval EFI_SUCCESS       The constructor executed correctly.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
VarCheckPolicyLibCommonConstructor (\r
  VOID\r
  )\r
{\r
  EFI_STATUS    Status;\r
  EFI_HANDLE    DiscardedHandle;\r
\r
  // Initialize the business logic with the internal GetVariable handler.\r
  Status = InitVariablePolicyLib( VariableServiceGetVariable );\r
\r
  // Only proceed with init if the business logic could be initialized.\r
  if (!EFI_ERROR( Status )) {\r
    // Register the VarCheck handler for SetVariable filtering.\r
    // Forward the check to the business logic of the library.\r
    VarCheckLibRegisterSetVariableCheckHandler( ValidateSetVariable );\r
\r
    // Register the MMI handlers for receiving policy commands.\r
    DiscardedHandle = NULL;\r
    Status = gMmst->MmiHandlerRegister( VarCheckPolicyLibMmiHandler,\r
                                        &gVarCheckPolicyLibMmiHandlerGuid,\r
                                        &DiscardedHandle );\r
  }\r
  // Otherwise, there's not much we can do.\r
  else {\r
    DEBUG(( DEBUG_ERROR, "%a - Cannot Initialize VariablePolicyLib! %r\n", __FUNCTION__, Status ));\r
    ASSERT_EFI_ERROR( Status );\r
  }\r
\r
  return Status;\r
}\r
Commit	Line	Data
483449c9 BB	1	/** @file -- VarCheckPolicyLib.c\r
	2	This is a NULL library instance that leverages the VarCheck interface\r
	3	and the business logic behind the VariablePolicy code to make its decisions.\r
	4	\r
	5	Copyright (c) Microsoft Corporation.\r
	6	SPDX-License-Identifier: BSD-2-Clause-Patent\r
	7	\r
	8	**/\r
	9	\r
	10	#include <Library/VarCheckLib.h>\r
	11	#include <Library/BaseLib.h>\r
	12	#include <Library/DebugLib.h>\r
	13	#include <Library/SafeIntLib.h>\r
	14	#include <Library/MmServicesTableLib.h>\r
483449c9 BB	15	#include <Library/BaseMemoryLib.h>\r
	16	#include <Library/MemoryAllocationLib.h>\r
	17	\r
	18	#include <Protocol/MmCommunication.h>\r
	19	\r
	20	#include <Protocol/VariablePolicy.h>\r
	21	#include <Library/VariablePolicyLib.h>\r
	22	\r
	23	#include <Guid/VarCheckPolicyMmi.h>\r
	24	\r
e2747dbb MK	25	#include "VarCheckPolicyLib.h"\r
e2747dbb MK	26	\r
483449c9 BB	27	//================================================\r
	28	// As a VarCheck library, we're linked into the VariableServices\r
	29	// and may not be able to call them indirectly. To get around this,\r
	30	// use the internal GetVariable function to query the variable store.\r
	31	//================================================\r
	32	EFI_STATUS\r
	33	EFIAPI\r
	34	VariableServiceGetVariable (\r
	35	IN CHAR16 *VariableName,\r
	36	IN EFI_GUID *VendorGuid,\r
	37	OUT UINT32 *Attributes OPTIONAL,\r
	38	IN OUT UINTN *DataSize,\r
	39	OUT VOID *Data\r
	40	);\r
	41	\r
	42	\r
	43	UINT8 mSecurityEvalBuffer[VAR_CHECK_POLICY_MM_COMM_BUFFER_SIZE];\r
	44	\r
	45	// Pagination Cache Variables\r
	46	UINT8 *mPaginationCache = NULL;\r
	47	UINTN mPaginationCacheSize = 0;\r
	48	UINT32 mCurrentPaginationCommand = 0;\r
	49	\r
	50	\r
	51	/**\r
	52	MM Communication Handler to recieve commands from the DXE protocol for\r
	53	Variable Policies. This communication channel is used to register new policies\r
	54	and poll and toggle the enforcement of variable policies.\r
	55	\r
	56	@param[in] DispatchHandle All parameters standard to MM communications convention.\r
	57	@param[in] RegisterContext All parameters standard to MM communications convention.\r
	58	@param[in,out] CommBuffer All parameters standard to MM communications convention.\r
	59	@param[in,out] CommBufferSize All parameters standard to MM communications convention.\r
	60	\r
	61	@retval EFI_SUCCESS\r
	62	@retval EFI_INVALID_PARAMETER CommBuffer or CommBufferSize is null pointer.\r
	63	@retval EFI_INVALID_PARAMETER CommBuffer size is wrong.\r
	64	@retval EFI_INVALID_PARAMETER Revision or signature don't match.\r
	65	\r
	66	**/\r
	67	STATIC\r
	68	EFI_STATUS\r
	69	EFIAPI\r
	70	VarCheckPolicyLibMmiHandler (\r
	71	IN EFI_HANDLE DispatchHandle,\r
	72	IN CONST VOID *RegisterContext,\r
	73	IN OUT VOID *CommBuffer,\r
	74	IN OUT UINTN *CommBufferSize\r
	75	)\r
	76	{\r
	77	UINTN InternalCommBufferSize;\r
	78	VOID *InternalCommBuffer;\r
	79	EFI_STATUS Status;\r
	80	EFI_STATUS SubCommandStatus;\r
	81	VAR_CHECK_POLICY_COMM_HEADER *PolicyCommmHeader;\r
	82	VAR_CHECK_POLICY_COMM_HEADER *InternalPolicyCommmHeader;\r
	83	VAR_CHECK_POLICY_COMM_IS_ENABLED_PARAMS *IsEnabledParams;\r
	84	VAR_CHECK_POLICY_COMM_DUMP_PARAMS *DumpParamsIn;\r
	85	VAR_CHECK_POLICY_COMM_DUMP_PARAMS *DumpParamsOut;\r
	86	UINT8 *DumpInputBuffer;\r
	87	UINT8 *DumpOutputBuffer;\r
	88	UINTN DumpTotalPages;\r
	89	VARIABLE_POLICY_ENTRY *PolicyEntry;\r
	90	UINTN ExpectedSize;\r
91	UINT32 TempSize;\r
92	\r
93	Status = EFI_SUCCESS;\r
94	\r
95	//\r
96	// Validate some input parameters.\r
97	//\r
98	// If either of the pointers are NULL, we can't proceed.\r
99	if (CommBuffer == NULL \|\| CommBufferSize == NULL) {\r
100	DEBUG(( DEBUG_INFO, "%a - Invalid comm buffer pointers!\n", __FUNCTION__ ));\r
101	return EFI_INVALID_PARAMETER;\r
102	}\r
103	// Make sure that the buffer does not overlap SMM.\r
104	// This should be covered by the SmiManage infrastructure, but just to be safe...\r
105	InternalCommBufferSize = *CommBufferSize;\r
e2747dbb MK	106	if (InternalCommBufferSize > VAR_CHECK_POLICY_MM_COMM_BUFFER_SIZE \|\|\r
e2747dbb MK	107	!VarCheckPolicyIsBufferOutsideValid((UINTN)CommBuffer, (UINT64)InternalCommBufferSize)) {\r
483449c9 BB	108	DEBUG ((DEBUG_ERROR, "%a - Invalid CommBuffer supplied! 0x%016lX[0x%016lX]\n", __FUNCTION__, CommBuffer, InternalCommBufferSize));\r
	109	return EFI_INVALID_PARAMETER;\r
	110	}\r
	111	// If the size does not meet a minimum threshold, we cannot proceed.\r
	112	ExpectedSize = sizeof(VAR_CHECK_POLICY_COMM_HEADER);\r
	113	if (InternalCommBufferSize < ExpectedSize) {\r
	114	DEBUG(( DEBUG_INFO, "%a - Bad comm buffer size! %d < %d\n", __FUNCTION__, InternalCommBufferSize, ExpectedSize ));\r
	115	return EFI_INVALID_PARAMETER;\r
	116	}\r
	117	\r
	118	//\r
	119	// Before proceeding any further, copy the buffer internally so that we can compare\r
	120	// without worrying about TOCTOU.\r
	121	//\r
	122	InternalCommBuffer = &mSecurityEvalBuffer[0];\r
	123	CopyMem(InternalCommBuffer, CommBuffer, InternalCommBufferSize);\r
	124	PolicyCommmHeader = CommBuffer;\r
	125	InternalPolicyCommmHeader = InternalCommBuffer;\r
	126	// Check the revision and the signature of the comm header.\r
	127	if (InternalPolicyCommmHeader->Signature != VAR_CHECK_POLICY_COMM_SIG \|\|\r
	128	InternalPolicyCommmHeader->Revision != VAR_CHECK_POLICY_COMM_REVISION) {\r
	129	DEBUG(( DEBUG_INFO, "%a - Signature or revision are incorrect!\n", __FUNCTION__ ));\r
	130	// We have verified the buffer is not null and have enough size to hold Result field.\r
	131	PolicyCommmHeader->Result = EFI_INVALID_PARAMETER;\r
	132	return EFI_SUCCESS;\r
	133	}\r
	134	\r
	135	// If we're in the middle of a paginated dump and any other command is sent,\r
	136	// pagination cache must be cleared.\r
	137	if (mPaginationCache != NULL && InternalPolicyCommmHeader->Command != mCurrentPaginationCommand) {\r
	138	FreePool (mPaginationCache);\r
	139	mPaginationCache = NULL;\r
	140	mPaginationCacheSize = 0;\r
	141	mCurrentPaginationCommand = 0;\r
	142	}\r
	143	\r
	144	//\r
	145	// Now we can process the command as it was sent.\r
	146	//\r
	147	PolicyCommmHeader->Result = EFI_ABORTED; // Set a default return for incomplete commands.\r
	148	switch(InternalPolicyCommmHeader->Command) {\r
	149	case VAR_CHECK_POLICY_COMMAND_DISABLE:\r
	150	PolicyCommmHeader->Result = DisableVariablePolicy();\r
	151	break;\r
	152	\r
	153	case VAR_CHECK_POLICY_COMMAND_IS_ENABLED:\r
	154	// Make sure that we're dealing with a reasonable size.\r
	155	// This add should be safe because these are fixed sizes so far.\r
	156	ExpectedSize += sizeof(VAR_CHECK_POLICY_COMM_IS_ENABLED_PARAMS);\r
	157	if (InternalCommBufferSize < ExpectedSize) {\r
	158	DEBUG(( DEBUG_INFO, "%a - Bad comm buffer size! %d < %d\n", __FUNCTION__, InternalCommBufferSize, ExpectedSize ));\r
	159	PolicyCommmHeader->Result = EFI_INVALID_PARAMETER;\r
	160	break;\r
	161	}\r
	162	\r
	163	// Now that we know we've got a valid size, we can fill in the rest of the data.\r
	164	IsEnabledParams = (VAR_CHECK_POLICY_COMM_IS_ENABLED_PARAMS)((UINT8)CommBuffer + sizeof(VAR_CHECK_POLICY_COMM_HEADER));\r
	165	IsEnabledParams->State = IsVariablePolicyEnabled();\r
	166	PolicyCommmHeader->Result = EFI_SUCCESS;\r
	167	break;\r
	168	\r
	169	case VAR_CHECK_POLICY_COMMAND_REGISTER:\r
	170	// Make sure that we're dealing with a reasonable size.\r
	171	// This add should be safe because these are fixed sizes so far.\r
172	ExpectedSize += sizeof(VARIABLE_POLICY_ENTRY);\r
173	if (InternalCommBufferSize < ExpectedSize) {\r
174	DEBUG(( DEBUG_INFO, "%a - Bad comm buffer size! %d < %d\n", __FUNCTION__, InternalCommBufferSize, ExpectedSize ));\r
175	PolicyCommmHeader->Result = EFI_INVALID_PARAMETER;\r
176	break;\r
177	}\r
178	\r
179	// At the very least, we can assume that we're working with a valid policy entry.\r
180	// Time to compare its internal size.\r
181	PolicyEntry = (VARIABLE_POLICY_ENTRY)((UINT8)InternalCommBuffer + sizeof(VAR_CHECK_POLICY_COMM_HEADER));\r
182	if (PolicyEntry->Version != VARIABLE_POLICY_ENTRY_REVISION \|\|\r
183	PolicyEntry->Size < sizeof(VARIABLE_POLICY_ENTRY) \|\|\r
184	EFI_ERROR(SafeUintnAdd(sizeof(VAR_CHECK_POLICY_COMM_HEADER), PolicyEntry->Size, &ExpectedSize)) \|\|\r
185	InternalCommBufferSize < ExpectedSize) {\r
186	DEBUG(( DEBUG_INFO, "%a - Bad policy entry contents!\n", __FUNCTION__ ));\r
187	PolicyCommmHeader->Result = EFI_INVALID_PARAMETER;\r
188	break;\r
189	}\r
190	\r
191	PolicyCommmHeader->Result = RegisterVariablePolicy( PolicyEntry );\r
192	break;\r
193	\r
194	case VAR_CHECK_POLICY_COMMAND_DUMP:\r
195	// Make sure that we're dealing with a reasonable size.\r
196	// This add should be safe because these are fixed sizes so far.\r
197	ExpectedSize += sizeof(VAR_CHECK_POLICY_COMM_DUMP_PARAMS) + VAR_CHECK_POLICY_MM_DUMP_BUFFER_SIZE;\r
198	if (InternalCommBufferSize < ExpectedSize) {\r
199	DEBUG(( DEBUG_INFO, "%a - Bad comm buffer size! %d < %d\n", __FUNCTION__, InternalCommBufferSize, ExpectedSize ));\r
200	PolicyCommmHeader->Result = EFI_INVALID_PARAMETER;\r
201	break;\r
202	}\r
203	\r
204	// Now that we know we've got a valid size, we can fill in the rest of the data.\r
205	DumpParamsIn = (VAR_CHECK_POLICY_COMM_DUMP_PARAMS*)(InternalPolicyCommmHeader + 1);\r
206	DumpParamsOut = (VAR_CHECK_POLICY_COMM_DUMP_PARAMS*)(PolicyCommmHeader + 1);\r
207	\r
208	// If we're requesting the first page, initialize the cache and get the sizes.\r
209	if (DumpParamsIn->PageRequested == 0) {\r
210	if (mPaginationCache != NULL) {\r
211	FreePool (mPaginationCache);\r
212	mPaginationCache = NULL;\r
213	}\r
214	\r
215	// Determine what the required size is going to be.\r
216	DumpParamsOut->TotalSize = 0;\r
217	DumpParamsOut->PageSize = 0;\r
218	DumpParamsOut->HasMore = FALSE;\r
f8e6bcb6	219	TempSize = 0;\r
483449c9 BB	220	SubCommandStatus = DumpVariablePolicy (NULL, &TempSize);\r
	221	if (SubCommandStatus == EFI_BUFFER_TOO_SMALL && TempSize > 0) {\r
	222	mCurrentPaginationCommand = VAR_CHECK_POLICY_COMMAND_DUMP;\r
	223	mPaginationCacheSize = TempSize;\r
	224	DumpParamsOut->TotalSize = TempSize;\r
	225	mPaginationCache = AllocatePool (mPaginationCacheSize);\r
	226	if (mPaginationCache == NULL) {\r
	227	SubCommandStatus = EFI_OUT_OF_RESOURCES;\r
	228	}\r
	229	}\r
	230	\r
	231	// If we've allocated our pagination cache, we're good to cache.\r
	232	if (mPaginationCache != NULL) {\r
	233	SubCommandStatus = DumpVariablePolicy (mPaginationCache, &TempSize);\r
	234	}\r
	235	\r
	236	// Populate the remaining fields and we can boogie.\r
	237	if (!EFI_ERROR (SubCommandStatus) && mPaginationCache != NULL) {\r
	238	DumpParamsOut->HasMore = TRUE;\r
	239	}\r
	240	} else if (mPaginationCache != NULL) {\r
	241	DumpParamsOut->TotalSize = (UINT32)mPaginationCacheSize;\r
	242	DumpOutputBuffer = (UINT8*)(DumpParamsOut + 1);\r
	243	\r
	244	// Make sure that we don't over-index the cache.\r
	245	DumpTotalPages = mPaginationCacheSize / VAR_CHECK_POLICY_MM_DUMP_BUFFER_SIZE;\r
	246	if (mPaginationCacheSize % VAR_CHECK_POLICY_MM_DUMP_BUFFER_SIZE != 0) {\r
	247	DumpTotalPages++;\r
	248	}\r
	249	if (DumpParamsIn->PageRequested > DumpTotalPages) {\r
	250	SubCommandStatus = EFI_INVALID_PARAMETER;\r
	251	} else {\r
	252	// Figure out how far into the page cache we need to go for our next page.\r
	253	// We know the blind subtraction won't be bad because we already checked for page 0.\r
	254	DumpInputBuffer = &mPaginationCache[VAR_CHECK_POLICY_MM_DUMP_BUFFER_SIZE * (DumpParamsIn->PageRequested - 1)];\r
	255	TempSize = VAR_CHECK_POLICY_MM_DUMP_BUFFER_SIZE;\r
	256	// If we're getting the last page, adjust the PageSize.\r
	257	if (DumpParamsIn->PageRequested == DumpTotalPages) {\r
	258	TempSize = mPaginationCacheSize % VAR_CHECK_POLICY_MM_DUMP_BUFFER_SIZE;\r
	259	}\r
	260	CopyMem (DumpOutputBuffer, DumpInputBuffer, TempSize);\r
	261	DumpParamsOut->PageSize = TempSize;\r
	262	// If we just got the last page, settle up the cache.\r
	263	if (DumpParamsIn->PageRequested == DumpTotalPages) {\r
	264	DumpParamsOut->HasMore = FALSE;\r
	265	FreePool (mPaginationCache);\r
	266	mPaginationCache = NULL;\r
	267	mPaginationCacheSize = 0;\r
	268	mCurrentPaginationCommand = 0;\r
	269	// Otherwise, we could do more here.\r
	270	} else {\r
	271	DumpParamsOut->HasMore = TRUE;\r
	272	}\r
	273	\r
	274	// If we made it this far, we're basically good.\r
	275	SubCommandStatus = EFI_SUCCESS;\r
	276	}\r
	277	// If we've requested any other page than 0 and the cache is empty, we must have timed out.\r
	278	} else {\r
	279	DumpParamsOut->TotalSize = 0;\r
	280	DumpParamsOut->PageSize = 0;\r
	281	DumpParamsOut->HasMore = FALSE;\r
	282	SubCommandStatus = EFI_TIMEOUT;\r
	283	}\r
284	\r
285	// There's currently no use for this, but it shouldn't be hard to implement.\r
286	PolicyCommmHeader->Result = SubCommandStatus;\r
287	break;\r
288	\r
289	case VAR_CHECK_POLICY_COMMAND_LOCK:\r
290	PolicyCommmHeader->Result = LockVariablePolicy();\r
291	break;\r
292	\r
293	default:\r
294	// Mark unknown requested command as EFI_UNSUPPORTED.\r
295	DEBUG(( DEBUG_INFO, "%a - Invalid command requested! %d\n", __FUNCTION__, PolicyCommmHeader->Command ));\r
296	PolicyCommmHeader->Result = EFI_UNSUPPORTED;\r
297	break;\r
298	}\r
299	\r
300	DEBUG(( DEBUG_VERBOSE, "%a - Command %d returning %r.\n", __FUNCTION__,\r
301	PolicyCommmHeader->Command, PolicyCommmHeader->Result ));\r
302	\r
303	return Status;\r
304	}\r
305	\r
306	\r
307	/**\r
308	Constructor function of VarCheckPolicyLib to register VarCheck handler and\r
309	SW MMI handlers.\r
310	\r
483449c9 BB	311	@retval EFI_SUCCESS The constructor executed correctly.\r
	312	\r
	313	**/\r
	314	EFI_STATUS\r
	315	EFIAPI\r
e2747dbb MK	316	VarCheckPolicyLibCommonConstructor (\r
e2747dbb MK	317	VOID\r
483449c9 BB	318	)\r
	319	{\r
	320	EFI_STATUS Status;\r
	321	EFI_HANDLE DiscardedHandle;\r
	322	\r
	323	// Initialize the business logic with the internal GetVariable handler.\r
	324	Status = InitVariablePolicyLib( VariableServiceGetVariable );\r
	325	\r
	326	// Only proceed with init if the business logic could be initialized.\r
	327	if (!EFI_ERROR( Status )) {\r
	328	// Register the VarCheck handler for SetVariable filtering.\r
	329	// Forward the check to the business logic of the library.\r
	330	VarCheckLibRegisterSetVariableCheckHandler( ValidateSetVariable );\r
	331	\r
	332	// Register the MMI handlers for receiving policy commands.\r
	333	DiscardedHandle = NULL;\r
	334	Status = gMmst->MmiHandlerRegister( VarCheckPolicyLibMmiHandler,\r
	335	&gVarCheckPolicyLibMmiHandlerGuid,\r
	336	&DiscardedHandle );\r
	337	}\r
	338	// Otherwise, there's not much we can do.\r
	339	else {\r
	340	DEBUG(( DEBUG_ERROR, "%a - Cannot Initialize VariablePolicyLib! %r\n", __FUNCTION__, Status ));\r
	341	ASSERT_EFI_ERROR( Status );\r
	342	}\r
	343	\r
	344	return Status;\r
	345	}\r