OcSerializeLib.c

Go to the documentation of this file.

 
#include <Library/OcSerializeLib.h>
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
 
STATIC
CONST CHAR8 *
  mSchemaTypeNames[] = {
  [OC_SCHEMA_VALUE_BOOLEAN] = "boolean",
  [OC_SCHEMA_VALUE_INTEGER] = "integer",
  [OC_SCHEMA_VALUE_DATA]    = "data",
  [OC_SCHEMA_VALUE_STRING]  = "string",
  [OC_SCHEMA_VALUE_MDATA]   = "mdata"
};
 
STATIC
CONST CHAR8 *
GetSchemaTypeName (
  IN UINT32  Type
  )
{
  if (Type < ARRAY_SIZE (mSchemaTypeNames)) {
    return mSchemaTypeNames[Type];
  }
 
  return "custom";
}
 
OC_SCHEMA *
LookupConfigSchema (
  IN OC_SCHEMA    *SortedList,
  IN UINT32       Size,
  IN CONST CHAR8  *Name
  )
{
  UINT32  Start;
  UINT32  End;
  UINT32  Curr;
  INTN    Cmp;
 
  if (Size == 0) {
    return NULL;
  }
 
  //
  // Classic binary search in a sorted string list.
  //
  Start = 0;
  End   = Size - 1;
 
  while (Start <= End) {
    Curr = (Start + End) / 2;
    Cmp  = AsciiStrCmp (SortedList[Curr].Name, Name);
 
    if (Cmp == 0) {
      return &SortedList[Curr];
    } else if (Cmp < 0) {
      Start = Curr + 1;
    } else if (Curr > 0) {
      End = Curr - 1;
    } else {
      //
      // Even the first element does not match, required due to unsigned End.
      //
      return NULL;
    }
  }
 
  return NULL;
}
 
VOID
ParseSerializedDict (
  OUT  VOID                *Serialized,
  IN       XML_NODE        *Node,
  IN       OC_SCHEMA_INFO  *Info,
  IN       CONST CHAR8     *Context     OPTIONAL,
  IN  OUT  UINT32          *ErrorCount  OPTIONAL
  )
{
  UINT32       DictSize;
  UINT32       Index;
  UINT32       Index2;
  CONST CHAR8  *CurrentKey;
  XML_NODE     *CurrentValue;
  XML_NODE     *OldValue;
  OC_SCHEMA    *NewSchema;
 
  DictSize = PlistDictChildren (Node);
 
  for (Index = 0; Index < DictSize; Index++) {
    CurrentKey = PlistKeyValue (PlistDictChild (Node, Index, &CurrentValue));
 
    if (CurrentKey == NULL) {
      DEBUG ((DEBUG_WARN, "OCS: No serialized key at %u index, context <%a>!\n", Index, Context));
      if (ErrorCount != NULL) {
        ++*ErrorCount;
      }
 
      continue;
    }
 
    //
    // Skip comments.
    //
    if (CurrentKey[0] == '#') {
      continue;
    }
 
    DEBUG ((DEBUG_VERBOSE, "OCS: Parsing serialized at %a at %u index!\n", CurrentKey, Index));
 
    //
    // We do not protect from duplicating serialized entries.
    //
    NewSchema = LookupConfigSchema (Info->Dict.Schema, Info->Dict.SchemaSize, CurrentKey);
 
    if (NewSchema == NULL) {
      DEBUG ((DEBUG_WARN, "OCS: No schema for %a at %u index, context <%a>!\n", CurrentKey, Index, Context));
      if (ErrorCount != NULL) {
        ++*ErrorCount;
      }
 
      continue;
    }
 
    OldValue     = CurrentValue;
    CurrentValue = PlistNodeCast (CurrentValue, NewSchema->Type);
    if (CurrentValue == NULL) {
      DEBUG ((
        DEBUG_WARN,
        "OCS: No type match for %a at %u index, expected type %a got %a, context <%a>!\n",
        CurrentKey,
        Index,
        GetSchemaTypeName (NewSchema->Type),
        XmlNodeName (OldValue),
        Context
        ));
      if (ErrorCount != NULL) {
        ++*ErrorCount;
      }
 
      continue;
    }
 
    NewSchema->Apply (Serialized, CurrentValue, &NewSchema->Info, CurrentKey, ErrorCount);
  }
 
  DEBUG_CODE_BEGIN ();
 
  for (Index = 0; Index < Info->Dict.SchemaSize; ++Index) {
    if (Info->Dict.Schema[Index].Optional) {
      continue;
    }
 
    for (Index2 = 0; Index2 < DictSize; ++Index2) {
      CurrentKey = PlistKeyValue (PlistDictChild (Node, Index2, NULL));
 
      if (CurrentKey == NULL) {
        continue;
      }
 
      if (AsciiStrCmp (CurrentKey, Info->Dict.Schema[Index].Name) == 0) {
        break;
      }
    }
 
    if (Index2 == DictSize) {
      DEBUG ((
        DEBUG_WARN,
        "OCS: Missing key %a, context <%a>!\n",
        Info->Dict.Schema[Index].Name,
        Context
        ));
      if (ErrorCount != NULL) {
        ++*ErrorCount;
      }
    }
  }
 
  DEBUG_CODE_END ();
}
 
VOID
ParseSerializedValue (
  OUT  VOID                *Serialized,
  IN       XML_NODE        *Node,
  IN       OC_SCHEMA_INFO  *Info,
  IN       CONST CHAR8     *Context     OPTIONAL,
  IN  OUT  UINT32          *ErrorCount  OPTIONAL
  )
{
  BOOLEAN  Result;
  VOID     *Field;
  UINT32   Size;
 
  Result = FALSE;
  Field  = OC_SCHEMA_FIELD (Serialized, VOID, Info->Value.Field);
  Size   = Info->Value.FieldSize;
 
  switch (Info->Value.Type) {
    case OC_SCHEMA_VALUE_BOOLEAN:
      Result = PlistBooleanValue (Node, (BOOLEAN *)Field);
      break;
    case OC_SCHEMA_VALUE_INTEGER:
      Result = PlistIntegerValue (Node, Field, Size, FALSE);
      break;
    case OC_SCHEMA_VALUE_DATA:
      Result = PlistDataValue (Node, Field, &Size);
      break;
    case OC_SCHEMA_VALUE_STRING:
      Result = PlistStringValue (Node, Field, &Size);
      break;
    case OC_SCHEMA_VALUE_MDATA:
      Result = PlistMultiDataValue (Node, Field, &Size);
      break;
  }
 
  if (Result == FALSE) {
    DEBUG ((
      DEBUG_WARN,
      "OCS: Failed to parse %a field as value with type %a and <%a> contents, context <%a>!\n",
      XmlNodeName (Node),
      GetSchemaTypeName (Info->Value.Type),
      XmlNodeContent (Node) != NULL ? XmlNodeContent (Node) : "empty",
      Context
      ));
    if (ErrorCount != NULL) {
      ++*ErrorCount;
    }
  }
}
 
VOID
ParseSerializedBlob (
  OUT  VOID                *Serialized,
  IN       XML_NODE        *Node,
  IN       OC_SCHEMA_INFO  *Info,
  IN       CONST CHAR8     *Context     OPTIONAL,
  IN  OUT  UINT32          *ErrorCount  OPTIONAL
  )
{
  BOOLEAN  Result;
  VOID     *Field;
  UINT32   Size;
  VOID     *BlobMemory;
  UINT32   *BlobSize;
 
  Result = FALSE;
 
  switch (Info->Blob.Type) {
    case OC_SCHEMA_BLOB_DATA:
      Result = PlistDataSize (Node, &Size);
      break;
    case OC_SCHEMA_BLOB_STRING:
      Result = PlistStringSize (Node, &Size);
      break;
    case OC_SCHEMA_BLOB_MDATA:
      Result = PlistMultiDataSize (Node, &Size);
      break;
  }
 
  if (Result == FALSE) {
    DEBUG ((
      DEBUG_WARN,
      "OCS: Failed to calculate size of %a field containing <%a> as type %a, context <%a>!\n",
      XmlNodeName (Node),
      XmlNodeContent (Node) != NULL ? XmlNodeContent (Node) : "empty",
      GetSchemaTypeName (Info->Blob.Type),
      Context
      ));
    if (ErrorCount != NULL) {
      ++*ErrorCount;
    }
 
    return;
  }
 
  Field      = OC_SCHEMA_FIELD (Serialized, VOID, Info->Blob.Field);
  BlobMemory = OcBlobAllocate (Field, Size, &BlobSize);
 
  if (BlobMemory == NULL) {
    DEBUG ((
      DEBUG_INFO,
      "OCS: Failed to allocate %u bytes %a field of type %a, context <%a>!\n",
      Size,
      XmlNodeName (Node),
      GetSchemaTypeName (Info->Value.Type),
      Context
      ));
    if (ErrorCount != NULL) {
      ++*ErrorCount;
    }
 
    return;
  }
 
  Result = FALSE;
 
  switch (Info->Blob.Type) {
    case OC_SCHEMA_BLOB_DATA:
      Result = PlistDataValue (Node, (UINT8 *)BlobMemory, BlobSize);
      break;
    case OC_SCHEMA_BLOB_STRING:
      Result = PlistStringValue (Node, (CHAR8 *)BlobMemory, BlobSize);
      break;
    case OC_SCHEMA_BLOB_MDATA:
      Result = PlistMultiDataValue (Node, (UINT8 *)BlobMemory, BlobSize);
      break;
  }
 
  if (Result == FALSE) {
    DEBUG ((
      DEBUG_WARN,
      "OCS: Failed to parse %a field as blob with type %a and <%a> contents, context <%a>!\n",
      XmlNodeName (Node),
      GetSchemaTypeName (Info->Value.Type),
      XmlNodeContent (Node) != NULL ? XmlNodeContent (Node) : "empty",
      Context
      ));
    if (ErrorCount != NULL) {
      ++*ErrorCount;
    }
  }
}
 
VOID
ParseSerializedMap (
  OUT  VOID                *Serialized,
  IN       XML_NODE        *Node,
  IN       OC_SCHEMA_INFO  *Info,
  IN       CONST CHAR8     *Context     OPTIONAL,
  IN  OUT  UINT32          *ErrorCount  OPTIONAL
  )
{
  UINT32       DictSize;
  UINT32       Index;
  CONST CHAR8  *CurrentKey;
  UINT32       CurrentKeyLen;
  XML_NODE     *ChildNode;
  VOID         *NewValue;
  VOID         *NewKey;
  VOID         *NewKeyValue;
  BOOLEAN      Success;
 
  DictSize = PlistDictChildren (Node);
 
  for (Index = 0; Index < DictSize; Index++) {
    CurrentKey    = PlistKeyValue (PlistDictChild (Node, Index, &ChildNode));
    CurrentKeyLen = CurrentKey != NULL ? (UINT32)(AsciiStrLen (CurrentKey) + 1) : 0;
 
    if (CurrentKeyLen == 0) {
      DEBUG ((DEBUG_INFO, "OCS: No get serialized key at %u index!\n", Index));
      if (ErrorCount != NULL) {
        ++*ErrorCount;
      }
 
      continue;
    }
 
    //
    // Skip comments.
    //
    if (CurrentKey[0] == '#') {
      continue;
    }
 
    if (PlistNodeCast (ChildNode, Info->List.Schema->Type) == NULL) {
      DEBUG ((DEBUG_INFO, "OCS: No valid serialized value at %u index!\n", Index));
      if (ErrorCount != NULL) {
        ++*ErrorCount;
      }
 
      continue;
    }
 
    Success = OcListEntryAllocate (
                OC_SCHEMA_FIELD (Serialized, VOID, Info->List.Field),
                &NewValue,
                &NewKey
                );
    if (Success == FALSE) {
      DEBUG ((DEBUG_INFO, "OCS: Couldn't insert dict serialized at %u index!\n", Index));
      if (ErrorCount != NULL) {
        ++*ErrorCount;
      }
 
      continue;
    }
 
    NewKeyValue = OcBlobAllocate (NewKey, CurrentKeyLen, NULL);
    if (NewKeyValue != NULL) {
      AsciiStrnCpyS ((CHAR8 *)NewKeyValue, CurrentKeyLen, CurrentKey, CurrentKeyLen - 1);
    } else {
      DEBUG ((DEBUG_INFO, "OCS: Couldn't allocate key name at %u index!\n", Index));
      if (ErrorCount != NULL) {
        ++*ErrorCount;
      }
    }
 
    Info->List.Schema->Apply (NewValue, ChildNode, &Info->List.Schema->Info, CurrentKey, ErrorCount);
  }
}
 
VOID
ParseSerializedArray (
  OUT  VOID                *Serialized,
  IN       XML_NODE        *Node,
  IN       OC_SCHEMA_INFO  *Info,
  IN       CONST CHAR8     *Context     OPTIONAL,
  IN  OUT  UINT32          *ErrorCount  OPTIONAL
  )
{
  UINT32    ArraySize;
  UINT32    Index;
  XML_NODE  *ChildNode;
  VOID      *NewValue;
  BOOLEAN   Success;
 
  ArraySize = XmlNodeChildren (Node);
 
  for (Index = 0; Index < ArraySize; Index++) {
    ChildNode = PlistNodeCast (XmlNodeChild (Node, Index), Info->List.Schema->Type);
 
    DEBUG ((DEBUG_VERBOSE, "OCS: Processing array %u/%u element\n", Index + 1, ArraySize));
 
    if (ChildNode == NULL) {
      DEBUG ((DEBUG_INFO, "OCS: Couldn't get array serialized at %u index!\n", Index));
      if (ErrorCount != NULL) {
        ++*ErrorCount;
      }
 
      continue;
    }
 
    Success = OcListEntryAllocate (
                OC_SCHEMA_FIELD (Serialized, VOID, Info->List.Field),
                &NewValue,
                NULL
                );
    if (Success == FALSE) {
      DEBUG ((DEBUG_INFO, "OCS: Couldn't insert array serialized at %u index!\n", Index));
      if (ErrorCount != NULL) {
        ++*ErrorCount;
      }
 
      continue;
    }
 
    Info->List.Schema->Apply (NewValue, ChildNode, &Info->List.Schema->Info, Context, ErrorCount);
  }
}
 
BOOLEAN
ParseSerialized (
  OUT  VOID                *Serialized,
  IN       OC_SCHEMA_INFO  *RootSchema,
  IN       VOID            *PlistBuffer,
  IN       UINT32          PlistSize,
  IN  OUT  UINT32          *ErrorCount  OPTIONAL
  )
{
  XML_DOCUMENT  *Document;
  XML_NODE      *RootDict;
 
  Document = XmlDocumentParse (PlistBuffer, PlistSize, FALSE);
 
  if (Document == NULL) {
    DEBUG ((DEBUG_INFO, "OCS: Couldn't parse serialized file!\n"));
    if (ErrorCount != NULL) {
      ++*ErrorCount;
    }
 
    return FALSE;
  }
 
  RootDict = PlistNodeCast (PlistDocumentRoot (Document), PLIST_NODE_TYPE_DICT);
 
  if (RootDict == NULL) {
    DEBUG ((DEBUG_INFO, "OCS: Couldn't get serialized root!\n"));
    XmlDocumentFree (Document);
    if (ErrorCount != NULL) {
      ++*ErrorCount;
    }
 
    return FALSE;
  }
 
  ParseSerializedDict (
    Serialized,
    RootDict,
    RootSchema,
    "root",
    ErrorCount
    );
 
  XmlDocumentFree (Document);
  return TRUE;
}