Utilities: Code split for ocvalidate (#176)

Utilities/ocvalidate/ValidateAcpi.c

@@ -48,8 +48,9 @@ ACPIAddHasDuplication (
   return StringIsDuplicated ("ACPI->Add", ACPIAddPrimaryPathString, ACPIAddSecondaryPathString);
 }
 
+STATIC
 UINT32
-CheckACPI (
+CheckACPIAdd (
   IN  OC_GLOBAL_CONFIG  *Config
   )
 {
@@ -58,25 +59,15 @@ CheckACPI (
   OC_ACPI_CONFIG  *UserAcpi;
   CONST CHAR8     *Path;
   CONST CHAR8     *Comment;
-  CONST UINT8     *Find;
-  UINT32          FindSize;
-  CONST UINT8     *Replace;
-  UINT32          ReplaceSize;
-  CONST UINT8     *Mask;
-  UINT32          MaskSize;
-  CONST UINT8     *ReplaceMask;
-  UINT32          ReplaceMaskSize;
   BOOLEAN         HasCustomDSDT;
 
-  DEBUG ((DEBUG_VERBOSE, "config loaded into ACPI checker!\n"));
-
-  ErrorCount    = 0;
-  UserAcpi      = &Config->Acpi;
-  HasCustomDSDT = FALSE;
+  ErrorCount      = 0;
+  UserAcpi        = &Config->Acpi;
+  HasCustomDSDT   = FALSE;
 
   for (Index = 0; Index < UserAcpi->Add.Count; ++Index) {
-    Path         = OC_BLOB_GET (&UserAcpi->Add.Values[Index]->Path);
-    Comment      = OC_BLOB_GET (&UserAcpi->Add.Values[Index]->Comment);
+    Path          = OC_BLOB_GET (&UserAcpi->Add.Values[Index]->Path);
+    Comment       = OC_BLOB_GET (&UserAcpi->Add.Values[Index]->Comment);
 
     //
     // Sanitise strings.
@@ -111,8 +102,33 @@ CheckACPI (
     ACPIAddHasDuplication
     );
 
+  //
+  // Check for RebaseRegions when using customised DSDT.
+  //
+  if (HasCustomDSDT && !UserAcpi->Quirks.RebaseRegions) {
+    DEBUG ((DEBUG_WARN, "ACPI->Quirks->RebaseRegions is not enabled when customised DSDT table is in use!\n"));
+    ++ErrorCount;
+  }
+
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckACPIDelete (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32          ErrorCount;
+  UINT32          Index;
+  OC_ACPI_CONFIG  *UserAcpi;
+  CONST CHAR8     *Comment;
+
+  ErrorCount      = 0;
+  UserAcpi        = &Config->Acpi;
+
   for (Index = 0; Index < UserAcpi->Delete.Count; ++Index) {
-    Comment = OC_BLOB_GET (&UserAcpi->Delete.Values[Index]->Comment);
+    Comment       = OC_BLOB_GET (&UserAcpi->Delete.Values[Index]->Comment);
 
     //
     // Sanitise strings.
@@ -128,6 +144,31 @@ CheckACPI (
     //
   }
 
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckACPIPatch (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32          ErrorCount;
+  UINT32          Index;
+  OC_ACPI_CONFIG  *UserAcpi;
+  CONST CHAR8     *Comment;
+  CONST UINT8     *Find;
+  UINT32          FindSize;
+  CONST UINT8     *Replace;
+  UINT32          ReplaceSize;
+  CONST UINT8     *Mask;
+  UINT32          MaskSize;
+  CONST UINT8     *ReplaceMask;
+  UINT32          ReplaceMaskSize;
+ 
+  ErrorCount      = 0;
+  UserAcpi        = &Config->Acpi;
+
   for (Index = 0; Index < UserAcpi->Patch.Count; ++Index) {
     Comment         = OC_BLOB_GET (&UserAcpi->Patch.Values[Index]->Comment);
     Find            = OC_BLOB_GET (&UserAcpi->Patch.Values[Index]->Find);
@@ -170,12 +211,28 @@ CheckACPI (
       ); 
   }
 
-  //
-  // Check for RebaseRegions when using customised DSDT.
-  //
-  if (HasCustomDSDT && !UserAcpi->Quirks.RebaseRegions) {
-    DEBUG ((DEBUG_WARN, "ACPI->Quirks->RebaseRegions is not enabled when customised DSDT table is in use!\n"));
-    ++ErrorCount;
+  return ErrorCount;
+}
+
+UINT32
+CheckACPI (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32  ErrorCount;
+  UINTN   Index;
+  STATIC CONFIG_CHECK ACPICheckers[] = {
+    &CheckACPIAdd,
+    &CheckACPIDelete,
+    &CheckACPIPatch
+  };
+
+  DEBUG ((DEBUG_VERBOSE, "config loaded into %a!\n", __func__));
+
+  ErrorCount  = 0;
+
+  for (Index = 0; Index < ARRAY_SIZE (ACPICheckers); ++Index) {
+    ErrorCount += ACPICheckers[Index] (Config);
   }
 
   return ReportError (__func__, ErrorCount);

Utilities/ocvalidate/ValidateBooter.c

@@ -16,54 +16,26 @@
 #include "ocvalidate.h"
 #include "OcValidateLib.h"
 
+STATIC
 UINT32
-CheckBooter (
+CheckBooterMmioWhitelist (
   IN  OC_GLOBAL_CONFIG  *Config
   )
 {
   UINT32            ErrorCount;
   UINT32            Index;
   OC_BOOTER_CONFIG  *UserBooter;
-  OC_UEFI_CONFIG    *UserUefi;
   CONST CHAR8       *Comment;
-  CONST CHAR8       *Arch;
-  CONST CHAR8       *Identifier;
-  CONST CHAR8       *Driver;
-  CONST UINT8       *Find;
-  UINT32            FindSize;
-  CONST UINT8       *Replace;
-  UINT32            ReplaceSize;
-  CONST UINT8       *Mask;
-  UINT32            MaskSize;
-  CONST UINT8       *ReplaceMask;
-  UINT32            ReplaceMaskSize;
-  UINT8             MaxSlide;
   BOOLEAN           IsMmioWhitelistEnabled;
   BOOLEAN           ShouldEnableDevirtualiseMmio;
   BOOLEAN           IsDevirtualiseMmioEnabled;
-  BOOLEAN           IsAllowRelocationBlockEnabled;
-  BOOLEAN           IsProvideCustomSlideEnabled;
-  BOOLEAN           IsEnableSafeModeSlideEnabled;
-  BOOLEAN           IsDisableVariableWriteEnabled;
-  BOOLEAN           IsEnableWriteUnprotectorEnabled;
-  BOOLEAN           HasOpenRuntimeEfiDriver;
-  
-  DEBUG ((DEBUG_VERBOSE, "config loaded into Booter checker!\n"));
 
   ErrorCount                      = 0;
   UserBooter                      = &Config->Booter;
-  UserUefi                        = &Config->Uefi;
   IsMmioWhitelistEnabled          = FALSE;
   ShouldEnableDevirtualiseMmio    = FALSE;
   IsDevirtualiseMmioEnabled       = UserBooter->Quirks.DevirtualiseMmio;
-  IsAllowRelocationBlockEnabled   = UserBooter->Quirks.AllowRelocationBlock;
-  IsProvideCustomSlideEnabled     = UserBooter->Quirks.ProvideCustomSlide;
-  IsEnableSafeModeSlideEnabled    = UserBooter->Quirks.EnableSafeModeSlide;
-  IsDisableVariableWriteEnabled   = UserBooter->Quirks.DisableVariableWrite;
-  IsEnableWriteUnprotectorEnabled = UserBooter->Quirks.EnableWriteUnprotector;
-  HasOpenRuntimeEfiDriver         = FALSE;
-  MaxSlide                        = UserBooter->Quirks.ProvideMaxSlide;
-  
+
   for (Index = 0; Index < UserBooter->MmioWhitelist.Count; ++Index) {
     Comment                = OC_BLOB_GET (&UserBooter->MmioWhitelist.Values[Index]->Comment);
     IsMmioWhitelistEnabled = UserBooter->MmioWhitelist.Values[Index]->Enabled;
@@ -81,6 +53,37 @@ CheckBooter (
     }
   }
 
+  if (ShouldEnableDevirtualiseMmio && !IsDevirtualiseMmioEnabled) {
+    DEBUG ((DEBUG_WARN, "There are enabled entries under Booter->MmioWhitelist, but DevirtualiseMmio is not enabled!\n"));
+    ++ErrorCount;
+  }
+
+  return ErrorCount;
+}
+
+UINT32
+CheckBooterPatch (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32            ErrorCount;
+  UINT32            Index;
+  OC_BOOTER_CONFIG  *UserBooter;
+  CONST CHAR8       *Comment;
+  CONST CHAR8       *Arch;
+  CONST CHAR8       *Identifier;
+  CONST UINT8       *Find;
+  UINT32            FindSize;
+  CONST UINT8       *Replace;
+  UINT32            ReplaceSize;
+  CONST UINT8       *Mask;
+  UINT32            MaskSize;
+  CONST UINT8       *ReplaceMask;
+  UINT32            ReplaceMaskSize;
+
+  ErrorCount        = 0;
+  UserBooter        = &Config->Booter;
+
   for (Index = 0; Index < UserBooter->Patch.Count; ++Index) {
     Comment         = OC_BLOB_GET (&UserBooter->Patch.Values[Index]->Comment);
     Arch            = OC_BLOB_GET (&UserBooter->Patch.Values[Index]->Arch);
@@ -128,6 +131,39 @@ CheckBooter (
       );
   }
 
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckBooterQuirks (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32            ErrorCount;
+  UINT32            Index;
+  OC_BOOTER_CONFIG  *UserBooter;
+  OC_UEFI_CONFIG    *UserUefi;
+  CONST CHAR8       *Driver;
+  UINT8             MaxSlide;
+  BOOLEAN           IsAllowRelocationBlockEnabled;
+  BOOLEAN           IsProvideCustomSlideEnabled;
+  BOOLEAN           IsEnableSafeModeSlideEnabled;
+  BOOLEAN           IsDisableVariableWriteEnabled;
+  BOOLEAN           IsEnableWriteUnprotectorEnabled;
+  BOOLEAN           HasOpenRuntimeEfiDriver;
+
+  ErrorCount                      = 0;
+  UserBooter                      = &Config->Booter;
+  UserUefi                        = &Config->Uefi;
+  IsAllowRelocationBlockEnabled   = UserBooter->Quirks.AllowRelocationBlock;
+  IsProvideCustomSlideEnabled     = UserBooter->Quirks.ProvideCustomSlide;
+  IsEnableSafeModeSlideEnabled    = UserBooter->Quirks.EnableSafeModeSlide;
+  IsDisableVariableWriteEnabled   = UserBooter->Quirks.DisableVariableWrite;
+  IsEnableWriteUnprotectorEnabled = UserBooter->Quirks.EnableWriteUnprotector;
+  HasOpenRuntimeEfiDriver         = FALSE;
+  MaxSlide                        = UserBooter->Quirks.ProvideMaxSlide;
+
   for (Index = 0; Index < UserUefi->Drivers.Count; ++Index) {
     Driver = OC_BLOB_GET (UserUefi->Drivers.Values[Index]);
 
@@ -140,10 +176,6 @@ CheckBooter (
     }
   }
 
-  if (ShouldEnableDevirtualiseMmio && !IsDevirtualiseMmioEnabled) {
-    DEBUG ((DEBUG_WARN, "There are enabled entries under Booter->MmioWhitelist, but DevirtualiseMmio is not enabled!\n"));
-    ++ErrorCount;
-  }
   if (!HasOpenRuntimeEfiDriver) {
     if (IsProvideCustomSlideEnabled) {
       DEBUG ((DEBUG_WARN, "Booter->Quirks->ProvideCustomSlide is enabled, but OpenRuntime.efi is not loaded at UEFI->Drivers!\n"));
@@ -158,6 +190,7 @@ CheckBooter (
       ++ErrorCount;
     }
   }
+
   if (!IsProvideCustomSlideEnabled) {
     if (IsAllowRelocationBlockEnabled) {
       DEBUG ((DEBUG_WARN, "Booter->Quirks->AllowRelocationBlock is enabled, but ProvideCustomSlide is not enabled altogether!\n"));
@@ -173,5 +206,29 @@ CheckBooter (
     }
   }
 
+  return ErrorCount;
+}
+
+UINT32
+CheckBooter (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32  ErrorCount;
+  UINTN   Index;
+  STATIC CONFIG_CHECK BooterCheckers[] = {
+    &CheckBooterMmioWhitelist,
+    &CheckBooterPatch,
+    &CheckBooterQuirks
+  };
+  
+  DEBUG ((DEBUG_VERBOSE, "config loaded into %a!\n", __func__));
+
+  ErrorCount  = 0;
+
+  for (Index = 0; Index < ARRAY_SIZE (BooterCheckers); ++Index) {
+    ErrorCount += BooterCheckers[Index] (Config);
+  }
+
   return ReportError (__func__, ErrorCount);
 }

Utilities/ocvalidate/ValidateDeviceProperties.c

@@ -72,8 +72,9 @@ DevPropsDeleteHasDuplication (
   return StringIsDuplicated ("DeviceProperties->Delete", DevPropsDeletePrimaryDevicePathString, DevPropsDeleteSecondaryDevicePathString);
 }
 
+STATIC
 UINT32
-CheckDeviceProperties (
+CheckDevicePropertiesAdd (
   IN  OC_GLOBAL_CONFIG  *Config
   )
 {
@@ -85,21 +86,21 @@ CheckDeviceProperties (
   CONST CHAR8               *AsciiProperty;
   OC_ASSOC                  *PropertyMap;
 
-  DEBUG ((DEBUG_VERBOSE, "config loaded into DeviceProperties checker!\n"));
-
-  ErrorCount  = 0;
+  ErrorCount = 0;
   UserDevProp = &Config->DeviceProperties;
 
-  for (DeviceIndex = 0; DeviceIndex < UserDevProp->Delete.Count; ++DeviceIndex) {
-    AsciiDevicePath   = OC_BLOB_GET (UserDevProp->Delete.Keys[DeviceIndex]);
+  for (DeviceIndex = 0; DeviceIndex < UserDevProp->Add.Count; ++DeviceIndex) {
+    AsciiDevicePath   = OC_BLOB_GET (UserDevProp->Add.Keys[DeviceIndex]);
     
     if (!AsciiDevicePathIsLegal (AsciiDevicePath)) {
-      DEBUG ((DEBUG_WARN, "DeviceProperties->Delete[%u]->DevicePath is borked! Please check the information above!\n", DeviceIndex));
+      DEBUG ((DEBUG_WARN, "DeviceProperties->Add[%u]->DevicePath is borked! Please check the information above!\n", DeviceIndex));
       ++ErrorCount;
     }
 
-    for (PropertyIndex = 0; PropertyIndex < UserDevProp->Delete.Values[DeviceIndex]->Count; ++PropertyIndex) {
-      AsciiProperty = OC_BLOB_GET (UserDevProp->Delete.Values[DeviceIndex]->Values[PropertyIndex]);
+    PropertyMap       = UserDevProp->Add.Values[DeviceIndex];
+    
+    for (PropertyIndex = 0; PropertyIndex < PropertyMap->Count; ++PropertyIndex) {
+      AsciiProperty = OC_BLOB_GET (PropertyMap->Keys[PropertyIndex]);
 
       //
       // Sanitise strings.
@@ -107,7 +108,7 @@ CheckDeviceProperties (
       if (!AsciiPropertyIsLegal (AsciiProperty)) {
         DEBUG ((
           DEBUG_WARN,
-          "DeviceProperties->Delete[%u]->Property[%u] contains illegal character!\n",
+          "DeviceProperties->Add[%u]->Property[%u] contains illegal character!\n",
           DeviceIndex,
           PropertyIndex
           ));
@@ -116,38 +117,55 @@ CheckDeviceProperties (
     }
 
     //
-    // Check duplicated properties in DeviceProperties->Delete[N].
+    // Check duplicated properties in DeviceProperties->Add[N].
     //
     ErrorCount += FindArrayDuplication (
-      UserDevProp->Delete.Values[DeviceIndex]->Values,
-      UserDevProp->Delete.Values[DeviceIndex]->Count,
-      sizeof (UserDevProp->Delete.Values[DeviceIndex]->Values[0]),
-      DevPropsDeleteHasDuplication
+      PropertyMap->Keys,
+      PropertyMap->Count,
+      sizeof (PropertyMap->Keys[0]),
+      DevPropsAddHasDuplication
       );
   }
 
   //
-  // Check duplicated entries in DeviceProperties->Delete.
+  // Check duplicated entries in DeviceProperties->Add.
   //
   ErrorCount += FindArrayDuplication (
-    UserDevProp->Delete.Keys,
-    UserDevProp->Delete.Count,
-    sizeof (UserDevProp->Delete.Keys[0]),
-    DevPropsDeleteHasDuplication
+    UserDevProp->Add.Keys,
+    UserDevProp->Add.Count,
+    sizeof (UserDevProp->Add.Keys[0]),
+    DevPropsAddHasDuplication
     );
 
-  for (DeviceIndex = 0; DeviceIndex < UserDevProp->Add.Count; ++DeviceIndex) {
-    AsciiDevicePath   = OC_BLOB_GET (UserDevProp->Add.Keys[DeviceIndex]);
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckDevicePropertiesDelete (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32                    ErrorCount;
+  UINT32                    DeviceIndex;
+  UINT32                    PropertyIndex;
+  OC_DEV_PROP_CONFIG        *UserDevProp;
+  CONST CHAR8               *AsciiDevicePath;
+  CONST CHAR8               *AsciiProperty;
+
+  ErrorCount  = 0;
+  UserDevProp = &Config->DeviceProperties;
+
+  for (DeviceIndex = 0; DeviceIndex < UserDevProp->Delete.Count; ++DeviceIndex) {
+    AsciiDevicePath   = OC_BLOB_GET (UserDevProp->Delete.Keys[DeviceIndex]);
     
     if (!AsciiDevicePathIsLegal (AsciiDevicePath)) {
-      DEBUG ((DEBUG_WARN, "DeviceProperties->Add[%u]->DevicePath is borked! Please check the information above!\n", DeviceIndex));
+      DEBUG ((DEBUG_WARN, "DeviceProperties->Delete[%u]->DevicePath is borked! Please check the information above!\n", DeviceIndex));
       ++ErrorCount;
     }
 
-    PropertyMap       = UserDevProp->Add.Values[DeviceIndex];
-    
-    for (PropertyIndex = 0; PropertyIndex < PropertyMap->Count; ++PropertyIndex) {
-      AsciiProperty = OC_BLOB_GET (PropertyMap->Keys[PropertyIndex]);
+    for (PropertyIndex = 0; PropertyIndex < UserDevProp->Delete.Values[DeviceIndex]->Count; ++PropertyIndex) {
+      AsciiProperty = OC_BLOB_GET (UserDevProp->Delete.Values[DeviceIndex]->Values[PropertyIndex]);
 
       //
       // Sanitise strings.
@@ -155,7 +173,7 @@ CheckDeviceProperties (
       if (!AsciiPropertyIsLegal (AsciiProperty)) {
         DEBUG ((
           DEBUG_WARN,
-          "DeviceProperties->Add[%u]->Property[%u] contains illegal character!\n",
+          "DeviceProperties->Delete[%u]->Property[%u] contains illegal character!\n",
           DeviceIndex,
           PropertyIndex
           ));
@@ -164,25 +182,48 @@ CheckDeviceProperties (
     }
 
     //
-    // Check duplicated properties in DeviceProperties->Add[N].
+    // Check duplicated properties in DeviceProperties->Delete[N].
     //
     ErrorCount += FindArrayDuplication (
-      PropertyMap->Keys,
-      PropertyMap->Count,
-      sizeof (PropertyMap->Keys[0]),
-      DevPropsAddHasDuplication
+      UserDevProp->Delete.Values[DeviceIndex]->Values,
+      UserDevProp->Delete.Values[DeviceIndex]->Count,
+      sizeof (UserDevProp->Delete.Values[DeviceIndex]->Values[0]),
+      DevPropsDeleteHasDuplication
       );
   }
 
   //
-  // Check duplicated entries in DeviceProperties->Add.
+  // Check duplicated entries in DeviceProperties->Delete.
   //
   ErrorCount += FindArrayDuplication (
-    UserDevProp->Add.Keys,
-    UserDevProp->Add.Count,
-    sizeof (UserDevProp->Add.Keys[0]),
-    DevPropsAddHasDuplication
+    UserDevProp->Delete.Keys,
+    UserDevProp->Delete.Count,
+    sizeof (UserDevProp->Delete.Keys[0]),
+    DevPropsDeleteHasDuplication
     );
 
+  return ErrorCount;
+}
+
+UINT32
+CheckDeviceProperties (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32  ErrorCount;
+  UINTN   Index;
+  STATIC CONFIG_CHECK DevicePropertiesCheckers[] = {
+    &CheckDevicePropertiesAdd,
+    &CheckDevicePropertiesDelete
+  };
+
+  DEBUG ((DEBUG_VERBOSE, "config loaded into %a!\n", __func__));
+
+  ErrorCount  = 0;
+
+  for (Index = 0; Index < ARRAY_SIZE (DevicePropertiesCheckers); ++Index) {
+    ErrorCount += DevicePropertiesCheckers[Index] (Config);
+  }
+
   return ReportError (__func__, ErrorCount);
 }

Utilities/ocvalidate/ValidateKernel.c

@@ -118,52 +118,32 @@ KernelForceHasDuplication (
   return StringIsDuplicated ("Kernel->Force", KernelForcePrimaryBundlePathString, KernelForceSecondaryBundlePathString);
 }
 
+STATIC
 UINT32
-CheckKernel (
+CheckKernelAdd (
   IN  OC_GLOBAL_CONFIG  *Config
   )
 {
-  UINT32              ErrorCount;
-  UINT32              Index;
-  OC_KERNEL_CONFIG    *UserKernel;
-  OC_PLATFORM_CONFIG  *UserPlatformInfo;
-  CONST CHAR8         *Arch;
-  CONST CHAR8         *BundlePath;
-  CONST CHAR8         *Comment;
-  CONST CHAR8         *ExecutablePath;
-  CONST CHAR8         *MaxKernel;
-  CONST CHAR8         *MinKernel;
-  CONST CHAR8         *PlistPath;
-  CONST CHAR8         *Identifier;
-  BOOLEAN             IsDisableLinkeditJettisonEnabled;
-  BOOLEAN             IsCustomSMBIOSGuidEnabled;
-  CONST CHAR8         *UpdateSMBIOSMode;
-  CONST CHAR8         *Base;
-  CONST UINT8         *Find;
-  UINT32              FindSize;
-  CONST UINT8         *Replace;
-  UINT32              ReplaceSize;
-  CONST UINT8         *Mask;
-  UINT32              MaskSize;
-  CONST UINT8         *ReplaceMask;
-  UINT32              ReplaceMaskSize;
-  CONST CHAR8         *KernelCache;
-  UINTN               IndexKextInfo;
-  UINTN               IndexKextPrecedence;
-  BOOLEAN             HasParent;
-  CONST CHAR8         *CurrentKext;
-  CONST CHAR8         *ParentKext;
-  CONST CHAR8         *ChildKext;
-
-  DEBUG ((DEBUG_VERBOSE, "config loaded into Kernel checker!\n"));
-
-  ErrorCount                       = 0;
-  UserKernel                       = &Config->Kernel;
-  UserPlatformInfo                 = &Config->PlatformInfo;
-  IsDisableLinkeditJettisonEnabled = UserKernel->Quirks.DisableLinkeditJettison;
-  IsCustomSMBIOSGuidEnabled        = UserKernel->Quirks.CustomSmbiosGuid;
-  UpdateSMBIOSMode                 = OC_BLOB_GET (&UserPlatformInfo->UpdateSmbiosMode);
-  KernelCache                      = OC_BLOB_GET (&UserKernel->Scheme.KernelCache);
+  UINT32            ErrorCount;
+  UINT32            Index;
+  OC_KERNEL_CONFIG  *UserKernel;
+  CONST CHAR8       *Arch;
+  CONST CHAR8       *BundlePath;
+  CONST CHAR8       *Comment;
+  CONST CHAR8       *ExecutablePath;
+  CONST CHAR8       *MaxKernel;
+  CONST CHAR8       *MinKernel;
+  CONST CHAR8       *PlistPath;
+  BOOLEAN           IsDisableLinkeditJettisonEnabled;
+  UINTN             IndexKextInfo;
+  UINTN             IndexKextPrecedence;
+  BOOLEAN           HasParent;
+  CONST CHAR8       *CurrentKext;
+  CONST CHAR8       *ParentKext;
+  CONST CHAR8       *ChildKext;
+
+  ErrorCount        = 0;
+  UserKernel        = &Config->Kernel;
 
   for (Index = 0; Index < UserKernel->Add.Count; ++Index) {
     Arch            = OC_BLOB_GET (&UserKernel->Add.Values[Index]->Arch);
@@ -238,6 +218,7 @@ CheckKernel (
           // Special check for Lilu and Quirks->DisableLinkeditJettison.
           //
           if (IndexKextInfo == INDEX_KEXT_LILU) {
+            IsDisableLinkeditJettisonEnabled = UserKernel->Quirks.DisableLinkeditJettison;
             if (!IsDisableLinkeditJettisonEnabled) {
               DEBUG ((DEBUG_WARN, "Lilu.kext is loaded at Kernel->Add[%u], but DisableLinkeditJettison is not enabled at Kernel->Quirks!\n", Index));
               ++ErrorCount;
@@ -277,13 +258,44 @@ CheckKernel (
           ++ErrorCount;
         }
         //
-        // Parent is already found before Child. Done.
+        // Parent is already found before Child as guaranteed by the first if. Done.
         //
         break;
       }
     }
   }
 
+  //
+  // Check duplicated entries in Kernel->Add.
+  //
+  ErrorCount += FindArrayDuplication (
+    UserKernel->Add.Values,
+    UserKernel->Add.Count,
+    sizeof (UserKernel->Add.Values[0]),
+    KernelAddHasDuplication
+    );
+
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckKernelBlock (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32            ErrorCount;
+  UINT32            Index;
+  OC_KERNEL_CONFIG  *UserKernel;
+  CONST CHAR8       *Arch;
+  CONST CHAR8       *Comment;
+  CONST CHAR8       *MaxKernel;
+  CONST CHAR8       *MinKernel;
+  CONST CHAR8       *Identifier;
+
+  ErrorCount        = 0;
+  UserKernel        = &Config->Kernel;
+
   for (Index = 0; Index < UserKernel->Block.Count; ++Index) {
     Arch            = OC_BLOB_GET (&UserKernel->Block.Values[Index]->Arch);
     Comment         = OC_BLOB_GET (&UserKernel->Block.Values[Index]->Comment);
@@ -320,6 +332,33 @@ CheckKernel (
     }
   }
 
+  //
+  // Check duplicated entries in Kernel->Block.
+  //
+  ErrorCount += FindArrayDuplication (
+    UserKernel->Block.Values,
+    UserKernel->Block.Count,
+    sizeof (UserKernel->Block.Values[0]),
+    KernelBlockHasDuplication
+    );
+
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckKernelEmulate (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32              ErrorCount;
+  OC_KERNEL_CONFIG    *UserKernel;
+  CONST CHAR8         *MaxKernel;
+  CONST CHAR8         *MinKernel;
+
+  ErrorCount          = 0;
+  UserKernel          = &Config->Kernel; 
+
   //
   // FIXME: Handle correct kernel version checking.
   //
@@ -339,6 +378,30 @@ CheckKernel (
     ++ErrorCount;
   }
 
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckKernelForce (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32            ErrorCount;
+  UINT32            Index;
+  OC_KERNEL_CONFIG  *UserKernel;
+  CONST CHAR8       *Arch;
+  CONST CHAR8       *BundlePath;
+  CONST CHAR8       *Comment;
+  CONST CHAR8       *ExecutablePath;
+  CONST CHAR8       *Identifier;
+  CONST CHAR8       *MaxKernel;
+  CONST CHAR8       *MinKernel;
+  CONST CHAR8       *PlistPath;
+
+  ErrorCount        = 0;
+  UserKernel        = &Config->Kernel;
+
   for (Index = 0; Index < UserKernel->Force.Count; ++Index) {
     Arch            = OC_BLOB_GET (&UserKernel->Force.Values[Index]->Arch);
     BundlePath      = OC_BLOB_GET (&UserKernel->Force.Values[Index]->BundlePath);
@@ -405,24 +468,63 @@ CheckKernel (
       DEBUG ((DEBUG_WARN, "Kernel->Force[%u]->MinKernel (currently set to %a) is borked!\n", Index, MinKernel));
       ++ErrorCount;
     }
-
   }
 
+  //
+  // Check duplicated entries in Kernel->Force.
+  //
+  ErrorCount += FindArrayDuplication (
+    UserKernel->Force.Values,
+    UserKernel->Force.Count,
+    sizeof (UserKernel->Force.Values[0]),
+    KernelForceHasDuplication
+    );
+
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckKernelPatch (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32              ErrorCount;
+  UINT32              Index;
+  OC_KERNEL_CONFIG    *UserKernel;
+  CONST CHAR8         *Arch;
+  CONST CHAR8         *Comment;
+  CONST CHAR8         *MaxKernel;
+  CONST CHAR8         *MinKernel;
+  CONST CHAR8         *Identifier;
+  CONST CHAR8         *Base;
+  CONST UINT8         *Find;
+  UINT32              FindSize;
+  CONST UINT8         *Replace;
+  UINT32              ReplaceSize;
+  CONST UINT8         *Mask;
+  UINT32              MaskSize;
+  CONST UINT8         *ReplaceMask;
+  UINT32              ReplaceMaskSize;
+
+  ErrorCount          = 0;
+  UserKernel          = &Config->Kernel;
+
   for (Index = 0; Index < UserKernel->Patch.Count; ++Index) {
-    Base            = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Base);
-    Comment         = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Comment);
-    Arch            = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Arch);
-    Identifier      = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Identifier);
-    Find            = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Find);
-    FindSize        = UserKernel->Patch.Values[Index]->Find.Size;
-    Replace         = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Replace);
-    ReplaceSize     = UserKernel->Patch.Values[Index]->Replace.Size;
-    Mask            = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Mask);
-    MaskSize        = UserKernel->Patch.Values[Index]->Mask.Size;
-    ReplaceMask     = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->ReplaceMask);
-    ReplaceMaskSize = UserKernel->Patch.Values[Index]->ReplaceMask.Size;
-    MaxKernel       = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->MaxKernel);
-    MinKernel       = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->MinKernel);
+    Base              = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Base);
+    Comment           = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Comment);
+    Arch              = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Arch);
+    Identifier        = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Identifier);
+    Find              = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Find);
+    FindSize          = UserKernel->Patch.Values[Index]->Find.Size;
+    Replace           = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Replace);
+    ReplaceSize       = UserKernel->Patch.Values[Index]->Replace.Size;
+    Mask              = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->Mask);
+    MaskSize          = UserKernel->Patch.Values[Index]->Mask.Size;
+    ReplaceMask       = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->ReplaceMask);
+    ReplaceMaskSize   = UserKernel->Patch.Values[Index]->ReplaceMask.Size;
+    MaxKernel         = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->MaxKernel);
+    MinKernel         = OC_BLOB_GET (&UserKernel->Patch.Values[Index]->MinKernel);
 
     //
     // Sanitise strings.
@@ -470,27 +572,51 @@ CheckKernel (
       );
   }
 
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckKernelQuirks (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32              ErrorCount;
+  OC_KERNEL_CONFIG    *UserKernel;
+  OC_PLATFORM_CONFIG  *UserPlatformInfo;
+  BOOLEAN             IsCustomSMBIOSGuidEnabled;
+  CONST CHAR8         *UpdateSMBIOSMode;
+
+  ErrorCount          = 0;
+  UserKernel          = &Config->Kernel;
+  UserPlatformInfo    = &Config->PlatformInfo;
+
   //
-  // Check duplicated entries in Kernel section.
+  // CustomSMBIOSGuid quirk requires UpdateSMBIOSMode at PlatformInfo set to Custom.
   //
-  ErrorCount += FindArrayDuplication (
-    UserKernel->Add.Values,
-    UserKernel->Add.Count,
-    sizeof (UserKernel->Add.Values[0]),
-    KernelAddHasDuplication
-    );
-  ErrorCount += FindArrayDuplication (
-    UserKernel->Block.Values,
-    UserKernel->Block.Count,
-    sizeof (UserKernel->Block.Values[0]),
-    KernelBlockHasDuplication
-    );
-  ErrorCount += FindArrayDuplication (
-    UserKernel->Force.Values,
-    UserKernel->Force.Count,
-    sizeof (UserKernel->Force.Values[0]),
-    KernelForceHasDuplication
-    );
+  IsCustomSMBIOSGuidEnabled = UserKernel->Quirks.CustomSmbiosGuid;
+  UpdateSMBIOSMode          = OC_BLOB_GET (&UserPlatformInfo->UpdateSmbiosMode);
+  if (IsCustomSMBIOSGuidEnabled && AsciiStrCmp (UpdateSMBIOSMode, "Custom") != 0) {
+    DEBUG ((DEBUG_WARN, "Kernel->Quirks->CustomSMBIOSGuid is enabled, but PlatformInfo->UpdateSMBIOSMode is not set to Custom!\n"));
+    ++ErrorCount;
+  }
+
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckKernelScheme (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32              ErrorCount;
+  OC_KERNEL_CONFIG    *UserKernel;
+  CONST CHAR8         *Arch;
+  CONST CHAR8         *KernelCache;
+
+  ErrorCount          = 0;
+  UserKernel          = &Config->Kernel;
 
   //
   // Sanitise Kernel->Scheme keys.
@@ -501,6 +627,7 @@ CheckKernel (
     ++ErrorCount;
   }
 
+  KernelCache = OC_BLOB_GET (&UserKernel->Scheme.KernelCache);
   if (AsciiStrCmp (KernelCache, "Auto") != 0
     && AsciiStrCmp (KernelCache, "Cacheless") != 0
     && AsciiStrCmp (KernelCache, "Mkext") != 0
@@ -509,12 +636,37 @@ CheckKernel (
     ++ErrorCount;
   }
 
+  return ErrorCount;
+}
+
+UINT32
+CheckKernel (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32  ErrorCount;
+  UINTN   Index;
+  STATIC CONFIG_CHECK KernelCheckers[] = {
+    &CheckKernelAdd,
+    &CheckKernelBlock,
+    &CheckKernelEmulate,
+    &CheckKernelForce,
+    &CheckKernelPatch,
+    &CheckKernelQuirks,
+    &CheckKernelScheme
+  };
+
+  DEBUG ((DEBUG_VERBOSE, "config loaded into %a!\n", __func__));
+
+  ErrorCount = 0;
+
   //
-  // CustomSMBIOSGuid quirk requires UpdateSMBIOSMode at PlatformInfo set to Custom.
+  // Ensure correct kext info prior to verification.
   //
-  if (IsCustomSMBIOSGuidEnabled && AsciiStrCmp (UpdateSMBIOSMode, "Custom") != 0) {
-    DEBUG ((DEBUG_WARN, "Kernel->Quirks->CustomSMBIOSGuid is enabled, but PlatformInfo->UpdateSMBIOSMode is not set to Custom!\n"));
-    ++ErrorCount;
+  ValidateKextInfo ();
+
+  for (Index = 0; Index < ARRAY_SIZE (KernelCheckers); ++Index) {
+    ErrorCount += KernelCheckers[Index] (Config);
   }
 
   return ReportError (__func__, ErrorCount);

Utilities/ocvalidate/ValidateMisc.c

@@ -140,74 +140,30 @@ ValidateSecureBootModel (
   return FALSE;
 }
 
+STATIC
 UINT32
-CheckMisc (
+CheckMiscBoot (
   IN  OC_GLOBAL_CONFIG  *Config
   )
 {
   UINT32            ErrorCount;
-  UINT32            Index;
-  OC_KERNEL_CONFIG  *UserKernel;
   OC_MISC_CONFIG    *UserMisc;
-  OC_UEFI_CONFIG    *UserUefi;
   UINT32            ConsoleAttributes;
   CONST CHAR8       *HibernateMode;
   UINT32            PickerAttributes;
   CONST CHAR8       *PickerMode;
   CONST CHAR8       *PickerVariant;
-  UINT64            DisplayLevel;
-  UINT64            AllowedDisplayLevel;
-  UINT64            HaltLevel;
-  UINT64            AllowedHaltLevel;
-  UINT32            Target;
-  BOOLEAN           IsAuthRestartEnabled;
-  BOOLEAN           HasVSMCKext;
-  CONST CHAR8       *BootProtect;
-  BOOLEAN           IsRequestBootVarRoutingEnabled;
-  CONST CHAR8       *AsciiDmgLoading;
-  UINT32            ExposeSensitiveData;
-  CONST CHAR8       *AsciiVault;
-  UINT32            ScanPolicy;
-  UINT32            AllowedScanPolicy;
-  CONST CHAR8       *SecureBootModel;
-  CONST CHAR8       *Arguments;
-  CONST CHAR8       *Comment;
-  CONST CHAR8       *AsciiName;
-  CONST CHAR16      *UnicodeName;
-  CONST CHAR8       *Path;
 
-  DEBUG ((DEBUG_VERBOSE, "config loaded into Misc checker!\n"));
-
-  ErrorCount                     = 0;
-  UserKernel                     = &Config->Kernel;
-  UserMisc                       = &Config->Misc;
-  UserUefi                       = &Config->Uefi;
-  ConsoleAttributes              = UserMisc->Boot.ConsoleAttributes;
-  HibernateMode                  = OC_BLOB_GET (&UserMisc->Boot.HibernateMode);
-  PickerAttributes               = UserMisc->Boot.PickerAttributes;
-  PickerMode                     = OC_BLOB_GET (&UserMisc->Boot.PickerMode);
-  PickerVariant                  = OC_BLOB_GET (&UserMisc->Boot.PickerVariant);
-  DisplayLevel                   = UserMisc->Debug.DisplayLevel;
-  AllowedDisplayLevel            = DEBUG_WARN | DEBUG_INFO | DEBUG_VERBOSE | DEBUG_ERROR;
-  HaltLevel                      = DisplayLevel;
-  AllowedHaltLevel               = AllowedDisplayLevel;
-  Target                         = UserMisc->Debug.Target;
-  IsAuthRestartEnabled           = UserMisc->Security.AuthRestart;
-  HasVSMCKext                    = FALSE;
-  BootProtect                    = OC_BLOB_GET (&UserMisc->Security.BootProtect);
-  IsRequestBootVarRoutingEnabled = UserUefi->Quirks.RequestBootVarRouting;
-  AsciiDmgLoading                = OC_BLOB_GET (&UserMisc->Security.DmgLoading);
-  ExposeSensitiveData            = UserMisc->Security.ExposeSensitiveData;
-  AsciiVault                     = OC_BLOB_GET (&UserMisc->Security.Vault);
-  ScanPolicy                     = UserMisc->Security.ScanPolicy;
-  AllowedScanPolicy              = OC_SCAN_FILE_SYSTEM_LOCK | OC_SCAN_DEVICE_LOCK | OC_SCAN_DEVICE_BITS | OC_SCAN_FILE_SYSTEM_BITS;
-  SecureBootModel                = OC_BLOB_GET (&UserMisc->Security.SecureBootModel);
+  ErrorCount        = 0;
+  UserMisc          = &Config->Misc;
 
+  ConsoleAttributes = UserMisc->Boot.ConsoleAttributes;
   if ((ConsoleAttributes & ~0x7FU) != 0) {
     DEBUG ((DEBUG_WARN, "Misc->Boot->ConsoleAttributes has unknown bits set!\n"));
     ++ErrorCount;
   }
 
+  HibernateMode     = OC_BLOB_GET (&UserMisc->Boot.HibernateMode);
   if (AsciiStrCmp (HibernateMode, "None") != 0
     && AsciiStrCmp (HibernateMode, "Auto") != 0
     && AsciiStrCmp (HibernateMode, "RTC") != 0
@@ -216,6 +172,7 @@ CheckMisc (
     ++ErrorCount;
   }
 
+  PickerAttributes  = UserMisc->Boot.PickerAttributes;
   if ((PickerAttributes & ~OC_ATTR_ALL_BITS) != 0) {
     DEBUG ((DEBUG_WARN, "Misc->Boot->PickerAttributes is has unknown bits set!\n"));
     ++ErrorCount;
@@ -224,6 +181,7 @@ CheckMisc (
   //
   // FIXME: Is OpenCanopy.efi mandatory if set to External? Or is this just a suggestion?
   //
+  PickerMode        = OC_BLOB_GET (&UserMisc->Boot.PickerMode);
   if (AsciiStrCmp (PickerMode, "Builtin") != 0
     && AsciiStrCmp (PickerMode, "External") != 0
     && AsciiStrCmp (PickerMode, "Apple") != 0) {
@@ -231,38 +189,169 @@ CheckMisc (
     ++ErrorCount;
   }
 
+  PickerVariant     = OC_BLOB_GET (&UserMisc->Boot.PickerVariant);
   if (PickerVariant[0] == '\0') {
     DEBUG ((DEBUG_WARN, "Misc->Boot->PickerVariant cannot be empty!\n"));
     ++ErrorCount;
   }
 
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckMiscDebug (
+  IN  OC_GLOBAL_CONFIG  *Config
+  ) 
+{
+  UINT32              ErrorCount;
+  OC_MISC_CONFIG      *UserMisc;
+  UINT64              DisplayLevel;
+  UINT64              AllowedDisplayLevel;
+  UINT64              HaltLevel;
+  UINT64              AllowedHaltLevel;
+  UINT32              Target;
+
+  ErrorCount          = 0;
+  UserMisc            = &Config->Misc;
+
   //
   // FIXME: Check whether DisplayLevel only supports values within AllowedDisplayLevel, or all possible levels in DebugLib.h?
   //
+  DisplayLevel        = UserMisc->Debug.DisplayLevel;
+  AllowedDisplayLevel = DEBUG_WARN | DEBUG_INFO | DEBUG_VERBOSE | DEBUG_ERROR;
   if ((DisplayLevel & ~AllowedDisplayLevel) != 0) {
     DEBUG ((DEBUG_WARN, "Misc->Debug->DisplayLevel is has unknown bits set!\n"));
     ++ErrorCount;
   }
+  HaltLevel           = DisplayLevel;
+  AllowedHaltLevel    = AllowedDisplayLevel;
   if ((HaltLevel & ~AllowedHaltLevel) != 0) {
     DEBUG ((DEBUG_WARN, "Misc->Security->HaltLevel has unknown bits set!\n"));
     ++ErrorCount;
   }
 
+  Target              = UserMisc->Debug.Target;
   if ((Target & ~OC_LOG_ALL_BITS) != 0) {
     DEBUG ((DEBUG_WARN, "Misc->Debug->Target has unknown bits set!\n"));
     ++ErrorCount;
   }
 
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckMiscEntries (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32            ErrorCount;
+  UINT32            Index;
+  OC_MISC_CONFIG    *UserMisc;
+  CONST CHAR8       *Arguments;
+  CONST CHAR8       *Comment;
+  CONST CHAR8       *AsciiName;
+  CONST CHAR16      *UnicodeName;
+  CONST CHAR8       *Path;
+
+  ErrorCount        = 0;
+  UserMisc          = &Config->Misc;
+
+  for (Index = 0; Index < UserMisc->Entries.Count; ++Index) {
+    Arguments       = OC_BLOB_GET (&UserMisc->Entries.Values[Index]->Arguments);
+    Comment         = OC_BLOB_GET (&UserMisc->Entries.Values[Index]->Comment);
+    AsciiName       = OC_BLOB_GET (&UserMisc->Entries.Values[Index]->Name);
+    Path            = OC_BLOB_GET (&UserMisc->Entries.Values[Index]->Path);
+
+    //
+    // Sanitise strings.
+    //
+    // NOTE: As Arguments takes identical requirements of Comment,
+    //       we use Comment sanitiser here.
+    //
+    if (!AsciiCommentIsLegal (Arguments)) {
+      DEBUG ((DEBUG_WARN, "Misc->Entries[%u]->Arguments contains illegal character!\n", Index));
+      ++ErrorCount;
+    }
+    if (!AsciiCommentIsLegal (Comment)) {
+      DEBUG ((DEBUG_WARN, "Misc->Entries[%u]->Comment contains illegal character!\n", Index));
+      ++ErrorCount;
+    }
+    
+    UnicodeName = AsciiStrCopyToUnicode (AsciiName, 0);
+    if (UnicodeName != NULL) {
+      if (!UnicodeIsFilteredString (UnicodeName, TRUE)) {
+        DEBUG ((DEBUG_WARN, "Misc->Entries[%u]->Name contains illegal character!\n", Index));
+        ++ErrorCount;
+      }
+
+      FreePool ((VOID *) UnicodeName);
+    }
+
+    //
+    // FIXME: Properly sanitise Path.
+    //
+    if (!AsciiCommentIsLegal (Path)) {
+      DEBUG ((DEBUG_WARN, "Misc->Entries[%u]->Path contains illegal character!\n", Index));
+      ++ErrorCount;
+    }
+  }
+
+  //
+  // Check duplicated entries in Entries.
+  //
+  ErrorCount += FindArrayDuplication (
+    UserMisc->Entries.Values,
+    UserMisc->Entries.Count,
+    sizeof (UserMisc->Entries.Values[0]),
+    MiscEntriesHasDuplication
+    );
+
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckMiscSecurity (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32            ErrorCount;
+  UINT32            Index;
+  OC_KERNEL_CONFIG  *UserKernel;
+  OC_MISC_CONFIG    *UserMisc;
+  OC_UEFI_CONFIG    *UserUefi;
+  BOOLEAN           IsAuthRestartEnabled;
+  BOOLEAN           HasVSMCKext;
+  CONST CHAR8       *BootProtect;
+  BOOLEAN           IsRequestBootVarRoutingEnabled;
+  CONST CHAR8       *AsciiDmgLoading;
+  UINT32            ExposeSensitiveData;
+  CONST CHAR8       *AsciiVault;
+  UINT32            ScanPolicy;
+  UINT32            AllowedScanPolicy;
+  CONST CHAR8       *SecureBootModel;
+
+  ErrorCount        = 0;
+  UserKernel        = &Config->Kernel;
+  UserMisc          = &Config->Misc;
+  UserUefi          = &Config->Uefi;
+
+  HasVSMCKext = FALSE;
   for (Index = 0; Index < UserKernel->Add.Count; ++Index) {
     if (AsciiStrCmp (OC_BLOB_GET (&UserKernel->Add.Values[Index]->BundlePath), mKextInfo[INDEX_KEXT_VSMC].KextBundlePath) == 0) {
       HasVSMCKext = TRUE;
     }
   }
+  IsAuthRestartEnabled = UserMisc->Security.AuthRestart;
   if (IsAuthRestartEnabled && !HasVSMCKext) {
     DEBUG ((DEBUG_WARN, "Misc->Security->AuthRestart is enabled, but VirtualSMC is not loaded at Kernel->Add!\n"));
     ++ErrorCount;
   }
 
+  BootProtect                    = OC_BLOB_GET (&UserMisc->Security.BootProtect);
+  IsRequestBootVarRoutingEnabled = UserUefi->Quirks.RequestBootVarRouting;
   if (AsciiStrCmp (BootProtect, "None") != 0
     && AsciiStrCmp (BootProtect, "Bootstrap") != 0
     && AsciiStrCmp (BootProtect, "BootstrapShort") != 0) {
@@ -279,6 +368,7 @@ CheckMisc (
     //
   }
 
+  AsciiDmgLoading = OC_BLOB_GET (&UserMisc->Security.DmgLoading);
   if (AsciiStrCmp (AsciiDmgLoading, "Disabled") != 0
     && AsciiStrCmp (AsciiDmgLoading, "Signed") != 0
     && AsciiStrCmp (AsciiDmgLoading, "Any") != 0) {
@@ -286,11 +376,13 @@ CheckMisc (
     ++ErrorCount;
   }
 
+  ExposeSensitiveData = UserMisc->Security.ExposeSensitiveData;
   if ((ExposeSensitiveData & ~OCS_EXPOSE_ALL_BITS) != 0) {
     DEBUG ((DEBUG_WARN, "Misc->Security->ExposeSensitiveData has unknown bits set!\n"));
     ++ErrorCount;
   }
 
+  AsciiVault = OC_BLOB_GET (&UserMisc->Security.Vault);
   if (AsciiStrCmp (AsciiVault, "Optional") != 0
     && AsciiStrCmp (AsciiVault, "Basic") != 0
     && AsciiStrCmp (AsciiVault, "Secure") != 0) {
@@ -298,8 +390,10 @@ CheckMisc (
     ++ErrorCount;
   }
 
+  ScanPolicy        = UserMisc->Security.ScanPolicy;
+  AllowedScanPolicy = OC_SCAN_FILE_SYSTEM_LOCK | OC_SCAN_DEVICE_LOCK | OC_SCAN_DEVICE_BITS | OC_SCAN_FILE_SYSTEM_BITS;
   //
-  // ScanPolicy can be zero (failsafe value).
+  // ScanPolicy can be zero (failsafe value), skipping such.
   //
   if (ScanPolicy != 0) {
     if ((ScanPolicy & ~AllowedScanPolicy) != 0) { 
@@ -321,58 +415,38 @@ CheckMisc (
   //
   // Validate SecureBootModel.
   //
+  SecureBootModel = OC_BLOB_GET (&UserMisc->Security.SecureBootModel);
   if (!ValidateSecureBootModel (SecureBootModel)) {
     DEBUG ((DEBUG_WARN, "Misc->Security->SecureBootModel is borked!\n"));
     ++ErrorCount;
   }
 
-  for (Index = 0; Index < UserMisc->Entries.Count; ++Index) {
-    Arguments    = OC_BLOB_GET (&UserMisc->Entries.Values[Index]->Arguments);
-    Comment      = OC_BLOB_GET (&UserMisc->Entries.Values[Index]->Comment);
-    AsciiName    = OC_BLOB_GET (&UserMisc->Entries.Values[Index]->Name);
-    Path         = OC_BLOB_GET (&UserMisc->Entries.Values[Index]->Path);
+  return ErrorCount;
+}
 
-    //
-    // Sanitise strings.
-    //
-    // NOTE: As Arguments takes identical requirements of Comment,
-    //       we use Comment sanitiser here.
-    //
-    if (!AsciiCommentIsLegal (Arguments)) {
-      DEBUG ((DEBUG_WARN, "Misc->Entries[%u]->Arguments contains illegal character!\n", Index));
-      ++ErrorCount;
-    }
-    if (!AsciiCommentIsLegal (Comment)) {
-      DEBUG ((DEBUG_WARN, "Misc->Entries[%u]->Comment contains illegal character!\n", Index));
-      ++ErrorCount;
-    }
-    
-    UnicodeName = AsciiStrCopyToUnicode (AsciiName, 0);
-    if (UnicodeName != NULL) {
-      if (!UnicodeIsFilteredString (UnicodeName, TRUE)) {
-        DEBUG ((DEBUG_WARN, "Misc->Entries[%u]->Name contains illegal character!\n", Index));
-        ++ErrorCount;
-      }
+STATIC
+UINT32
+CheckMiscTools (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32            ErrorCount;
+  UINT32            Index;
+  OC_MISC_CONFIG    *UserMisc;
+  CONST CHAR8       *Arguments;
+  CONST CHAR8       *Comment;
+  CONST CHAR8       *AsciiName;
+  CONST CHAR16      *UnicodeName;
+  CONST CHAR8       *Path;
 
-      FreePool ((VOID *) UnicodeName);
-    }
+  ErrorCount        = 0;
+  UserMisc          = &Config->Misc;
 
-    //
-    // FIXME: Properly sanitise Path.
-    //
-    if (!AsciiCommentIsLegal (Path)) {
-      DEBUG ((DEBUG_WARN, "Misc->Entries[%u]->Path contains illegal character!\n", Index));
-      ++ErrorCount;
-    }
-  }
-  //
-  // Same thing for Tools.
-  //
   for (Index = 0; Index < UserMisc->Tools.Count; ++Index) {
-    Arguments    = OC_BLOB_GET (&UserMisc->Tools.Values[Index]->Arguments);
-    Comment      = OC_BLOB_GET (&UserMisc->Tools.Values[Index]->Comment);
-    AsciiName    = OC_BLOB_GET (&UserMisc->Tools.Values[Index]->Name);
-    Path         = OC_BLOB_GET (&UserMisc->Tools.Values[Index]->Path);
+    Arguments       = OC_BLOB_GET (&UserMisc->Tools.Values[Index]->Arguments);
+    Comment         = OC_BLOB_GET (&UserMisc->Tools.Values[Index]->Comment);
+    AsciiName       = OC_BLOB_GET (&UserMisc->Tools.Values[Index]->Name);
+    Path            = OC_BLOB_GET (&UserMisc->Tools.Values[Index]->Path);
 
     //
     // Sanitise strings.
@@ -409,14 +483,8 @@ CheckMisc (
   }
 
   //
-  // Check duplicated entries in Entries and Tools.
+  // Check duplicated entries in Tools.
   //
-  ErrorCount += FindArrayDuplication (
-    UserMisc->Entries.Values,
-    UserMisc->Entries.Count,
-    sizeof (UserMisc->Entries.Values[0]),
-    MiscEntriesHasDuplication
-    );
   ErrorCount += FindArrayDuplication (
     UserMisc->Tools.Values,
     UserMisc->Tools.Count,
@@ -424,5 +492,31 @@ CheckMisc (
     MiscToolsHasDuplication
     );
 
+  return ErrorCount;
+}
+
+UINT32
+CheckMisc (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32  ErrorCount;
+  UINTN   Index;
+  STATIC CONFIG_CHECK MiscCheckers[] = {
+    &CheckMiscBoot,
+    &CheckMiscDebug,
+    &CheckMiscEntries,
+    &CheckMiscSecurity,
+    &CheckMiscTools
+  };
+
+  DEBUG ((DEBUG_VERBOSE, "config loaded into %a!\n", __func__));
+
+  ErrorCount = 0;
+
+  for (Index = 0; Index < ARRAY_SIZE (MiscCheckers); ++Index) {
+    ErrorCount += MiscCheckers[Index] (Config);
+  }
+
   return ReportError (__func__, ErrorCount);
 }

Utilities/ocvalidate/ValidateNVRAM.c

@@ -100,8 +100,9 @@ NVRAMLegacySchemaHasDuplication (
   return StringIsDuplicated ("NVRAM->LegacySchema", NVRAMLegacySchemaPrimaryGUIDString, NVRAMLegacySchemaSecondaryGUIDString);
 }
 
+STATIC
 UINT32
-CheckNVRAM (
+CheckNVRAMAdd (
   IN  OC_GLOBAL_CONFIG  *Config
   )
 {
@@ -113,8 +114,6 @@ CheckNVRAM (
   CONST CHAR8      *AsciiNVRAMKey;
   OC_ASSOC         *VariableMap;
 
-  DEBUG ((DEBUG_VERBOSE, "config loaded into NVRAM checker!\n"));
-
   ErrorCount = 0;
   UserNVRAM  = &Config->Nvram;
 
@@ -166,6 +165,25 @@ CheckNVRAM (
     NVRAMAddHasDuplication
     );
 
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckNVRAMDelete (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32           ErrorCount;
+  UINT32           GuidIndex;
+  UINT32           VariableIndex;
+  OC_NVRAM_CONFIG  *UserNVRAM;
+  CONST CHAR8      *AsciiGuid;
+  CONST CHAR8      *AsciiNVRAMKey;
+
+  ErrorCount = 0;
+  UserNVRAM  = &Config->Nvram;
+
   for (GuidIndex = 0; GuidIndex < UserNVRAM->Delete.Count; ++GuidIndex) {
     AsciiGuid = OC_BLOB_GET (UserNVRAM->Delete.Keys[GuidIndex]);
 
@@ -212,6 +230,25 @@ CheckNVRAM (
     NVRAMDeleteHasDuplication
     );
 
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckNVRAMSchema (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32           ErrorCount;
+  UINT32           GuidIndex;
+  UINT32           VariableIndex;
+  OC_NVRAM_CONFIG  *UserNVRAM;
+  CONST CHAR8      *AsciiGuid;
+  CONST CHAR8      *AsciiNVRAMKey;
+
+  ErrorCount = 0;
+  UserNVRAM  = &Config->Nvram;
+
   for (GuidIndex = 0; GuidIndex < UserNVRAM->Legacy.Count; ++GuidIndex) {
     AsciiGuid = OC_BLOB_GET (UserNVRAM->Legacy.Keys[GuidIndex]);
 
@@ -258,5 +295,30 @@ CheckNVRAM (
     NVRAMLegacySchemaHasDuplication
     );
 
+  return ErrorCount;
+}
+
+
+UINT32
+CheckNVRAM (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32  ErrorCount;
+  UINTN   Index;
+  STATIC CONFIG_CHECK NVRAMCheckers[] = {
+    &CheckNVRAMAdd,
+    &CheckNVRAMDelete,
+    &CheckNVRAMSchema
+  };
+
+  DEBUG ((DEBUG_VERBOSE, "config loaded into %a!\n", __func__));
+
+  ErrorCount = 0;
+
+  for (Index = 0; Index < ARRAY_SIZE (NVRAMCheckers); ++Index) {
+    ErrorCount += NVRAMCheckers[Index] (Config);
+  }
+
   return ReportError (__func__, ErrorCount);
 }

Utilities/ocvalidate/ValidatePlatformInfo.c

@@ -21,49 +21,29 @@
 //
 // NOTE: Only PlatformInfo->Generic is checked here. The rest is ignored.
 //
+
+STATIC
 UINT32
-CheckPlatformInfo (
+CheckPlatformInfoGeneric (
   IN  OC_GLOBAL_CONFIG  *Config
   )
 {
   UINT32              ErrorCount;
   OC_PLATFORM_CONFIG  *UserPlatformInfo;
-  BOOLEAN             IsAutomaticEnabled;
-  CONST CHAR8         *UpdateSMBIOSMode;
   CONST CHAR8         *SystemProductName;
   CONST CHAR8         *SystemMemoryStatus;
   CONST CHAR8         *AsciiSystemUUID;
 
-  DEBUG ((DEBUG_VERBOSE, "config loaded into PlatformInfo checker!\n"));
-
-  ErrorCount         = 0;
-  UserPlatformInfo   = &Config->PlatformInfo;
-  IsAutomaticEnabled = UserPlatformInfo->Automatic;
-  UpdateSMBIOSMode   = OC_BLOB_GET (&UserPlatformInfo->UpdateSmbiosMode);
-  SystemProductName  = OC_BLOB_GET (&UserPlatformInfo->Generic.SystemProductName);
-  SystemMemoryStatus = OC_BLOB_GET (&UserPlatformInfo->Generic.SystemMemoryStatus);
-  AsciiSystemUUID    = OC_BLOB_GET (&UserPlatformInfo->Generic.SystemUuid);
-
-  if (AsciiStrCmp (UpdateSMBIOSMode, "TryOverwrite") != 0
-    && AsciiStrCmp (UpdateSMBIOSMode, "Create") != 0
-    && AsciiStrCmp (UpdateSMBIOSMode, "Overwrite") != 0
-    && AsciiStrCmp (UpdateSMBIOSMode, "Custom") != 0) {
-    DEBUG ((DEBUG_WARN, "PlatformInfo->UpdateSMBIOSMode is borked (Can only be TryOverwrite, Create, Overwrite, or Custom)!\n"));
-    ++ErrorCount;
-  }
-
-  if (!IsAutomaticEnabled) {
-    //
-    // This is not an error, but we need to stop checking further.
-    //
-    return ReportError (__func__, ErrorCount);
-  }
+  ErrorCount          = 0;
+  UserPlatformInfo    = &Config->PlatformInfo;
 
+  SystemProductName   = OC_BLOB_GET (&UserPlatformInfo->Generic.SystemProductName);
   if (!HasMacInfo (SystemProductName)) {
     DEBUG ((DEBUG_WARN, "PlatformInfo->Generic->SystemProductName has unknown model set!\n"));
     ++ErrorCount;
   }
 
+  SystemMemoryStatus  = OC_BLOB_GET (&UserPlatformInfo->Generic.SystemMemoryStatus);
   if (AsciiStrCmp (SystemMemoryStatus, "Auto") != 0
     && AsciiStrCmp (SystemMemoryStatus, "Upgradable") != 0
     && AsciiStrCmp (SystemMemoryStatus, "Soldered") != 0) {
@@ -71,6 +51,7 @@ CheckPlatformInfo (
     ++ErrorCount;
   }
 
+  AsciiSystemUUID     = OC_BLOB_GET (&UserPlatformInfo->Generic.SystemUuid);
   if (AsciiSystemUUID[0] != '\0' && !AsciiGuidIsLegal (AsciiSystemUUID)) {
     DEBUG ((DEBUG_WARN, "PlatformInfo->Generic->SystemUUID is borked!\n"));
     ++ErrorCount;
@@ -80,5 +61,48 @@ CheckPlatformInfo (
   // TODO: Sanitise MLB, ProcessorType, and SystemSerialNumber if possible...
   //
 
+  return ErrorCount;
+}
+
+UINT32
+CheckPlatformInfo (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32              ErrorCount;
+  OC_PLATFORM_CONFIG  *UserPlatformInfo;
+  BOOLEAN             IsAutomaticEnabled;
+  CONST CHAR8         *UpdateSMBIOSMode;
+  UINTN               Index;
+  STATIC CONFIG_CHECK PlatformInfoCheckers[] = {
+    &CheckPlatformInfoGeneric
+  };
+
+  DEBUG ((DEBUG_VERBOSE, "config loaded into %a!\n", __func__));
+
+  ErrorCount          = 0;
+  UserPlatformInfo    = &Config->PlatformInfo;
+  
+  UpdateSMBIOSMode    = OC_BLOB_GET (&UserPlatformInfo->UpdateSmbiosMode);
+  if (AsciiStrCmp (UpdateSMBIOSMode, "TryOverwrite") != 0
+    && AsciiStrCmp (UpdateSMBIOSMode, "Create") != 0
+    && AsciiStrCmp (UpdateSMBIOSMode, "Overwrite") != 0
+    && AsciiStrCmp (UpdateSMBIOSMode, "Custom") != 0) {
+    DEBUG ((DEBUG_WARN, "PlatformInfo->UpdateSMBIOSMode is borked (Can only be TryOverwrite, Create, Overwrite, or Custom)!\n"));
+    ++ErrorCount;
+  }
+  
+  IsAutomaticEnabled = UserPlatformInfo->Automatic;
+  if (!IsAutomaticEnabled) {
+    //
+    // This is not an error, but we need to stop checking further.
+    //
+    return ReportError (__func__, ErrorCount);
+  }
+
+  for (Index = 0; Index < ARRAY_SIZE (PlatformInfoCheckers); ++Index) {
+    ErrorCount += PlatformInfoCheckers[Index] (Config);
+  }
+
   return ReportError (__func__, ErrorCount);
 }

Utilities/ocvalidate/ValidateUEFI.c

@@ -111,106 +111,93 @@ ValidateReservedMemoryType (
   return FALSE;
 }
 
+STATIC
 UINT32
-CheckUEFI (
+CheckUEFIAPFS (
   IN  OC_GLOBAL_CONFIG  *Config
   )
 {
-  UINT32                    ErrorCount;
-  UINT32                    Index;
-  UINT32                    IndexOpenUsbKbDxeEfiDriver;
-  UINT32                    IndexPs2KeyboardDxeEfiDriver;
-  OC_UEFI_CONFIG            *UserUefi;
-  OC_MISC_CONFIG            *UserMisc;
-  CONST CHAR8               *Driver;
-  CONST CHAR8               *TextRenderer;
-  CONST CHAR8               *ConsoleMode;
-  CONST CHAR8               *PointerSupportMode;
-  CONST CHAR8               *KeySupportMode;
-  BOOLEAN                   HasOpenRuntimeEfiDriver;
-  BOOLEAN                   HasOpenUsbKbDxeEfiDriver;
-  BOOLEAN                   HasPs2KeyboardDxeEfiDriver;
-  BOOLEAN                   HasHfsEfiDriver;
-  BOOLEAN                   HasAudioDxeEfiDriver;
-  BOOLEAN                   IsConnectDriversEnabled;
-  BOOLEAN                   IsRequestBootVarRoutingEnabled;
-  BOOLEAN                   IsKeySupportEnabled;
-  BOOLEAN                   IsTextRendererSystem;
-  BOOLEAN                   IsClearScreenOnModeSwitchEnabled;
-  BOOLEAN                   IsIgnoreTextInGraphicsEnabled;
-  BOOLEAN                   IsReplaceTabWithSpaceEnabled;
-  BOOLEAN                   IsSanitiseClearScreenEnabled;
-  BOOLEAN                   IsPointerSupportEnabled;
-  CONST CHAR8               *Resolution;
-  UINT32                    UserWidth;
-  UINT32                    UserHeight;
-  UINT32                    UserBpp;
-  BOOLEAN                   UserSetMax;
-  CONST CHAR8               *AsciiAudioDevicePath;
-  CONST CHAR8               *AsciiReservedMemoryType;
-  UINT64                    ReservedMemoryAddress;
-  UINT64                    ReservedMemorySize;
-
-  DEBUG ((DEBUG_VERBOSE, "config loaded into UEFI checker!\n"));
-
-  ErrorCount                       = 0;
-  IndexOpenUsbKbDxeEfiDriver       = 0;
-  IndexPs2KeyboardDxeEfiDriver     = 0;
-  UserUefi                         = &Config->Uefi;
-  UserMisc                         = &Config->Misc;
-  HasOpenRuntimeEfiDriver          = FALSE;
-  HasOpenUsbKbDxeEfiDriver         = FALSE;
-  HasPs2KeyboardDxeEfiDriver       = FALSE;
-  HasHfsEfiDriver                  = FALSE;
-  HasAudioDxeEfiDriver             = FALSE;
-  IsConnectDriversEnabled          = UserUefi->ConnectDrivers;
-  IsRequestBootVarRoutingEnabled   = UserUefi->Quirks.RequestBootVarRouting;
-  IsKeySupportEnabled              = UserUefi->Input.KeySupport;
-  IsPointerSupportEnabled          = UserUefi->Input.PointerSupport;
-  PointerSupportMode               = OC_BLOB_GET (&UserUefi->Input.PointerSupportMode);
-  KeySupportMode                   = OC_BLOB_GET (&UserUefi->Input.KeySupportMode);
-  IsClearScreenOnModeSwitchEnabled = UserUefi->Output.ClearScreenOnModeSwitch;
-  IsIgnoreTextInGraphicsEnabled    = UserUefi->Output.IgnoreTextInGraphics;
-  IsReplaceTabWithSpaceEnabled     = UserUefi->Output.ReplaceTabWithSpace;
-  IsSanitiseClearScreenEnabled     = UserUefi->Output.SanitiseClearScreen;
-  TextRenderer                     = OC_BLOB_GET (&UserUefi->Output.TextRenderer);
-  IsTextRendererSystem             = FALSE;
-  ConsoleMode                      = OC_BLOB_GET (&UserUefi->Output.ConsoleMode);
-  Resolution                       = OC_BLOB_GET (&UserUefi->Output.Resolution);
-  AsciiAudioDevicePath             = OC_BLOB_GET (&UserUefi->Audio.AudioDevice);
+  UINT32                   ErrorCount;
+  OC_UEFI_CONFIG           *UserUefi;
+  OC_MISC_CONFIG           *UserMisc;
+  BOOLEAN                  IsEnableJumpstartEnabled;
+  UINT32                   ScanPolicy;
 
-  //
-  // Sanitise strings.
-  //
-  if (AsciiStrCmp (TextRenderer, "BuiltinGraphics") != 0
-    && AsciiStrCmp (TextRenderer, "BuiltinText") != 0
-    && AsciiStrCmp (TextRenderer, "SystemGraphics") != 0
-    && AsciiStrCmp (TextRenderer, "SystemText") != 0
-    && AsciiStrCmp (TextRenderer, "SystemGeneric") != 0) {
-    DEBUG ((DEBUG_WARN, "UEFI->Output->TextRenderer is illegal (Can only be BuiltinGraphics, BuiltinText, SystemGraphics, SystemText, or SystemGeneric)!\n"));
-    ++ErrorCount;
-  } else if (AsciiStrnCmp (TextRenderer, "System", L_STR_LEN ("System")) == 0) {
-    //
-    // Check whether TextRenderer has System prefix.
-    //
-    IsTextRendererSystem = TRUE;
-  }
+  ErrorCount               = 0;
+  UserUefi                 = &Config->Uefi;
+  UserMisc                 = &Config->Misc;
 
   //
   // If FS restrictions is enabled but APFS FS scanning is disabled, it is an error.
   //
-  if (UserUefi->Apfs.EnableJumpstart
-    && (UserMisc->Security.ScanPolicy & OC_SCAN_FILE_SYSTEM_LOCK) != 0
-    && (UserMisc->Security.ScanPolicy & OC_SCAN_ALLOW_FS_APFS) == 0) {
+  IsEnableJumpstartEnabled = UserUefi->Apfs.EnableJumpstart;
+  ScanPolicy               = UserMisc->Security.ScanPolicy;
+  if (IsEnableJumpstartEnabled
+    && (ScanPolicy & OC_SCAN_FILE_SYSTEM_LOCK) != 0
+    && (ScanPolicy & OC_SCAN_ALLOW_FS_APFS) == 0) {
     DEBUG ((DEBUG_WARN, "UEFI->APFS->EnableJumpstart is enabled, but Misc->Security->ScanPolicy does not allow APFS scanning!\n"));
     ++ErrorCount;
   }
 
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckUEFIAudio (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32                   ErrorCount;
+  OC_UEFI_CONFIG           *UserUefi;
+  CONST CHAR8              *AsciiAudioDevicePath;
+
+  ErrorCount               = 0;
+  UserUefi                 = &Config->Uefi;
+  AsciiAudioDevicePath     = OC_BLOB_GET (&UserUefi->Audio.AudioDevice);
+
   if (AsciiAudioDevicePath[0] != '\0' && !AsciiDevicePathIsLegal (AsciiAudioDevicePath)) {
     DEBUG ((DEBUG_WARN, "UEFI->Audio->AudioDevice is borked! Please check the information above!\n"));
     ++ErrorCount;
   }
 
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckUEFIDrivers (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32                       ErrorCount;
+  OC_UEFI_CONFIG               *UserUefi;
+  UINT32                       Index;
+  CONST CHAR8                  *Driver;
+  BOOLEAN                      HasOpenRuntimeEfiDriver;
+  BOOLEAN                      HasOpenUsbKbDxeEfiDriver;
+  UINT32                       IndexOpenUsbKbDxeEfiDriver;
+  BOOLEAN                      HasPs2KeyboardDxeEfiDriver;
+  BOOLEAN                      IndexPs2KeyboardDxeEfiDriver;
+  BOOLEAN                      HasHfsEfiDriver;
+  UINT32                       IndexHfsEfiDriver;
+  BOOLEAN                      HasAudioDxeEfiDriver;
+  UINT32                       IndexAudioDxeEfiDriver;
+  BOOLEAN                      IsRequestBootVarRoutingEnabled;
+  BOOLEAN                      IsKeySupportEnabled;
+  BOOLEAN                      IsConnectDriversEnabled;
+
+  ErrorCount                   = 0;
+  UserUefi                     = &Config->Uefi;
+
+  HasOpenRuntimeEfiDriver      = FALSE;
+  HasOpenUsbKbDxeEfiDriver     = FALSE;
+  IndexOpenUsbKbDxeEfiDriver   = 0;
+  HasPs2KeyboardDxeEfiDriver   = FALSE;
+  IndexPs2KeyboardDxeEfiDriver = 0;
+  HasHfsEfiDriver              = FALSE;
+  IndexHfsEfiDriver            = 0;
+  HasAudioDxeEfiDriver         = FALSE;
   for (Index = 0; Index < UserUefi->Drivers.Count; ++Index) {
     Driver = OC_BLOB_GET (UserUefi->Drivers.Values[Index]);
 
@@ -239,10 +226,12 @@ CheckUEFI (
     // Here only "hfs" (case-insensitive) is matched.
     //
     if (OcAsciiStriStr (Driver, "hfs") != NULL) {
-      HasHfsEfiDriver = TRUE;
+      HasHfsEfiDriver   = TRUE;
+      IndexHfsEfiDriver = Index;
     }
     if (AsciiStrCmp (Driver, "AudioDxe.efi") == 0) {
-      HasAudioDxeEfiDriver = TRUE;
+      HasAudioDxeEfiDriver   = TRUE;
+      IndexAudioDxeEfiDriver = Index;
     }
   }
 
@@ -256,19 +245,7 @@ CheckUEFI (
     UEFIDriverHasDuplication
     );
 
-  if (IsPointerSupportEnabled && AsciiStrCmp (PointerSupportMode, "ASUS") != 0) {
-    DEBUG ((DEBUG_WARN, "UEFI->Input->PointerSupport is enabled, but PointerSupportMode is not ASUS!\n"));
-    ++ErrorCount;
-  }
-
-  if (AsciiStrCmp (KeySupportMode, "Auto") != 0
-    && AsciiStrCmp (KeySupportMode, "V1") != 0
-    && AsciiStrCmp (KeySupportMode, "V2") != 0
-    && AsciiStrCmp (KeySupportMode, "AMI") != 0) {
-    DEBUG ((DEBUG_WARN, "UEFI->Input->KeySupportMode is illegal (Can only be Auto, V1, V2, AMI)!\n"));
-    ++ErrorCount;
-  }
-
+  IsRequestBootVarRoutingEnabled = UserUefi->Quirks.RequestBootVarRouting;
   if (IsRequestBootVarRoutingEnabled) {
     if (!HasOpenRuntimeEfiDriver) {
       DEBUG ((DEBUG_WARN, "UEFI->Quirks->RequestBootVarRouting is enabled, but OpenRuntime.efi is not loaded at UEFI->Drivers!\n"));
@@ -276,6 +253,7 @@ CheckUEFI (
     }
   }
 
+  IsKeySupportEnabled = UserUefi->Input.KeySupport;
   if (IsKeySupportEnabled) {
     if (HasOpenUsbKbDxeEfiDriver) {
       DEBUG ((DEBUG_WARN, "OpenUsbKbDxe.efi at UEFI->Drivers[%u] should NEVER be used together with UEFI->Input->KeySupport!\n", IndexOpenUsbKbDxeEfiDriver));
@@ -298,30 +276,118 @@ CheckUEFI (
     ++ErrorCount;
   }
 
+  IsConnectDriversEnabled = UserUefi->ConnectDrivers;
   if (!IsConnectDriversEnabled) {
     if (HasHfsEfiDriver) {
-      DEBUG ((DEBUG_WARN, "HFS+ filesystem driver is loaded, but UEFI->ConnectDrivers is not enabled!\n"));
+      DEBUG ((DEBUG_WARN, "HFS+ filesystem driver is loaded at UEFI->Drivers[%u], but UEFI->ConnectDrivers is not enabled!\n", IndexHfsEfiDriver));
       ++ErrorCount;
     }
     if (HasAudioDxeEfiDriver) {
-      DEBUG ((DEBUG_WARN, "AudioDevice.efi is loaded, but UEFI->ConnectDrivers is not enabled!\n"));
+      DEBUG ((DEBUG_WARN, "AudioDevice.efi is loaded at UEFI->Drivers[%u], but UEFI->ConnectDrivers is not enabled!\n", IndexAudioDxeEfiDriver));
       ++ErrorCount;
     }
   }
 
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckUEFIInput (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32          ErrorCount;
+  OC_UEFI_CONFIG  *UserUefi;
+  BOOLEAN         IsPointerSupportEnabled;
+  CONST CHAR8     *PointerSupportMode;
+  CONST CHAR8     *KeySupportMode;
+
+  ErrorCount      = 0;
+  UserUefi        = &Config->Uefi;
+
+  IsPointerSupportEnabled = UserUefi->Input.PointerSupport;
+  PointerSupportMode      = OC_BLOB_GET (&UserUefi->Input.PointerSupportMode);
+  if (IsPointerSupportEnabled && AsciiStrCmp (PointerSupportMode, "ASUS") != 0) {
+    DEBUG ((DEBUG_WARN, "UEFI->Input->PointerSupport is enabled, but PointerSupportMode is not ASUS!\n"));
+    ++ErrorCount;
+  }
+
+  KeySupportMode = OC_BLOB_GET (&UserUefi->Input.KeySupportMode);
+  if (AsciiStrCmp (KeySupportMode, "Auto") != 0
+    && AsciiStrCmp (KeySupportMode, "V1") != 0
+    && AsciiStrCmp (KeySupportMode, "V2") != 0
+    && AsciiStrCmp (KeySupportMode, "AMI") != 0) {
+    DEBUG ((DEBUG_WARN, "UEFI->Input->KeySupportMode is illegal (Can only be Auto, V1, V2, AMI)!\n"));
+    ++ErrorCount;
+  }
+
+  return ErrorCount;
+}
+
+STATIC
+UINT32
+CheckUEFIOutput (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32               ErrorCount;
+  OC_UEFI_CONFIG       *UserUefi;
+  CONST CHAR8          *TextRenderer;
+  BOOLEAN              IsTextRendererSystem;
+  BOOLEAN              IsClearScreenOnModeSwitchEnabled;
+  BOOLEAN              IsIgnoreTextInGraphicsEnabled;
+  BOOLEAN              IsReplaceTabWithSpaceEnabled;
+  BOOLEAN              IsSanitiseClearScreenEnabled;
+  CONST CHAR8          *ConsoleMode;
+  CONST CHAR8          *Resolution;
+  UINT32               UserWidth;
+  UINT32               UserHeight;
+  UINT32               UserBpp;
+  BOOLEAN              UserSetMax;
+
+  ErrorCount           = 0;
+  UserUefi             = &Config->Uefi;
+  IsTextRendererSystem = FALSE;
+
+  //
+  // Sanitise strings.
+  //
+  TextRenderer = OC_BLOB_GET (&UserUefi->Output.TextRenderer);
+  if (AsciiStrCmp (TextRenderer, "BuiltinGraphics") != 0
+    && AsciiStrCmp (TextRenderer, "BuiltinText") != 0
+    && AsciiStrCmp (TextRenderer, "SystemGraphics") != 0
+    && AsciiStrCmp (TextRenderer, "SystemText") != 0
+    && AsciiStrCmp (TextRenderer, "SystemGeneric") != 0) {
+    DEBUG ((DEBUG_WARN, "UEFI->Output->TextRenderer is illegal (Can only be BuiltinGraphics, BuiltinText, SystemGraphics, SystemText, or SystemGeneric)!\n"));
+    ++ErrorCount;
+  } else if (AsciiStrnCmp (TextRenderer, "System", L_STR_LEN ("System")) == 0) {
+    //
+    // Check whether TextRenderer has System prefix.
+    //
+    IsTextRendererSystem = TRUE;
+  }
+
   if (!IsTextRendererSystem) {
+    IsClearScreenOnModeSwitchEnabled = UserUefi->Output.ClearScreenOnModeSwitch;
     if (IsClearScreenOnModeSwitchEnabled) {
       DEBUG ((DEBUG_WARN, "UEFI->Output->ClearScreenOnModeSwitch is enabled on non-System TextRenderer (currently %a)!\n", TextRenderer));
       ++ErrorCount;
     }
+
+    IsIgnoreTextInGraphicsEnabled    = UserUefi->Output.IgnoreTextInGraphics;
     if (IsIgnoreTextInGraphicsEnabled) {
       DEBUG ((DEBUG_WARN, "UEFI->Output->IgnoreTextInGraphics is enabled on non-System TextRenderer (currently %a)!\n", TextRenderer));
       ++ErrorCount;
     }
+
+    IsReplaceTabWithSpaceEnabled     = UserUefi->Output.ReplaceTabWithSpace;
     if (IsReplaceTabWithSpaceEnabled) {
       DEBUG ((DEBUG_WARN, "UEFI->Output->ReplaceTabWithSpace is enabled on non-System TextRenderer (currently %a)!\n", TextRenderer));
       ++ErrorCount;
     }
+
+    IsSanitiseClearScreenEnabled     = UserUefi->Output.SanitiseClearScreen;
     if (IsSanitiseClearScreenEnabled) {
       DEBUG ((DEBUG_WARN, "UEFI->Output->SanitiseClearScreen is enabled on non-System TextRenderer (currently %a)!\n", TextRenderer));
       ++ErrorCount;
@@ -331,6 +397,7 @@ CheckUEFI (
   //
   // Parse Output->ConsoleMode by calling OpenCore libraries.
   //
+  ConsoleMode = OC_BLOB_GET (&UserUefi->Output.ConsoleMode);
   OcParseConsoleMode (
     ConsoleMode,
     &UserWidth,
@@ -347,6 +414,7 @@ CheckUEFI (
   //
   // Parse Output->Resolution by calling OpenCore libraries.
   //
+  Resolution = OC_BLOB_GET (&UserUefi->Output.Resolution);
   OcParseScreenResolution (
     Resolution,
     &UserWidth,
@@ -361,6 +429,37 @@ CheckUEFI (
     ++ErrorCount;
   }
 
+  return ErrorCount;
+}
+
+//
+// FIXME: Just in case this can be of use...
+//
+STATIC
+UINT32
+CheckUEFIQuirks (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  return 0;
+}
+
+STATIC
+UINT32
+CheckUEFIReservedMemory (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32          ErrorCount;
+  UINT32          Index;
+  OC_UEFI_CONFIG  *UserUefi;
+  CONST CHAR8     *AsciiReservedMemoryType;
+  UINT64          ReservedMemoryAddress;
+  UINT64          ReservedMemorySize;
+
+  ErrorCount      = 0;
+  UserUefi        = &Config->Uefi;
+
   //
   // Validate ReservedMemory[N].
   //
@@ -397,5 +496,33 @@ CheckUEFI (
     UEFIReservedMemoryHasOverlap
     );
 
+  return ErrorCount;
+}
+
+UINT32
+CheckUEFI (
+  IN  OC_GLOBAL_CONFIG  *Config
+  )
+{
+  UINT32  ErrorCount;
+  UINTN   Index;
+  STATIC CONFIG_CHECK UEFICheckers[] = {
+    &CheckUEFIAPFS,
+    &CheckUEFIAudio,
+    &CheckUEFIDrivers,
+    &CheckUEFIInput,
+    &CheckUEFIOutput,
+    &CheckUEFIQuirks,
+    &CheckUEFIReservedMemory
+  };
+
+  DEBUG ((DEBUG_VERBOSE, "config loaded into %a!\n", __func__));
+
+  ErrorCount = 0;
+  
+  for (Index = 0; Index < ARRAY_SIZE (UEFICheckers); ++Index) {
+    ErrorCount += UEFICheckers[Index] (Config);
+  }
+
   return ReportError (__func__, ErrorCount);
 }

Utilities/ocvalidate/ocvalidate.c

@@ -15,7 +15,6 @@
 
 #include "ocvalidate.h"
 #include "OcValidateLib.h"
-#include "KextInfo.h"
 
 #include <OpenCore.h>
 
@@ -41,11 +40,6 @@ CheckConfig (
 
   ErrorCount = 0;
 
-  //
-  // Ensure correct kext info prior to verification.
-  //
-  ValidateKextInfo ();
-
   //
   // Pass config structure to all checkers.
   //