JsonLib.c

Go to the documentation of this file.

 
#include <Uefi.h>
#include <Library/JsonLib.h>
#include <Library/BaseUcs2Utf8Lib.h>
#include <Library/MemoryAllocationLib.h>
 
#include "jansson.h"
 
extern volatile UINT32  hashtable_seed;
 
EDKII_JSON_VALUE
EFIAPI
JsonValueInitArray (
  VOID
  )
{
  return (EDKII_JSON_VALUE)json_array ();
}
 
EDKII_JSON_VALUE
EFIAPI
JsonValueInitObject (
  VOID
  )
{
  return (EDKII_JSON_VALUE)json_object ();
}
 
EDKII_JSON_VALUE
EFIAPI
JsonValueInitAsciiString (
  IN    CONST CHAR8  *String
  )
{
  UINTN  Index;
 
  if (String == NULL) {
    return NULL;
  }
 
  Index = 0;
  while (*(String + Index) != '\0') {
    if (((*(String + Index)) & 0x80) != 0x00) {
      return NULL;
    }
 
    Index++;
  }
 
  return (EDKII_JSON_VALUE)json_string (String);
}
 
EDKII_JSON_VALUE
EFIAPI
JsonValueInitUnicodeString (
  IN    CHAR16  *String
  )
{
  EFI_STATUS  Status;
  CHAR8       *Utf8Str;
 
  if (String == NULL) {
    return NULL;
  }
 
  Utf8Str = NULL;
  Status  = UCS2StrToUTF8 (String, &Utf8Str);
  if (EFI_ERROR (Status)) {
    return NULL;
  }
 
  return (EDKII_JSON_VALUE)json_string (Utf8Str);
}
 
EDKII_JSON_VALUE
EFIAPI
JsonValueInitInteger (
  IN    INT64  Value
  )
{
  return (EDKII_JSON_VALUE)json_integer (Value);
}
 
EDKII_JSON_VALUE
EFIAPI
JsonValueInitBoolean (
  IN    BOOLEAN  Value
  )
{
  return (EDKII_JSON_VALUE)json_boolean (Value);
}
 
EDKII_JSON_VALUE
EFIAPI
JsonValueInitTrue (
  VOID
  )
{
  return (EDKII_JSON_VALUE)json_true ();
}
 
EDKII_JSON_VALUE
EFIAPI
JsonValueInitFalse (
  VOID
  )
{
  return (EDKII_JSON_VALUE)json_false ();
}
 
EDKII_JSON_VALUE
EFIAPI
JsonValueInitNull (
  VOID
  )
{
  return (EDKII_JSON_VALUE)json_null ();
}
 
VOID
EFIAPI
JsonValueFree (
  IN    EDKII_JSON_VALUE  Json
  )
{
  json_decref ((json_t *)Json);
}
 
EDKII_JSON_VALUE
EFIAPI
JsonValueClone (
  IN    EDKII_JSON_VALUE  Json
  )
{
  return (EDKII_JSON_VALUE)json_deep_copy ((json_t *)Json);
}
 
BOOLEAN
EFIAPI
JsonValueIsArray (
  IN    EDKII_JSON_VALUE  Json
  )
{
  return json_is_array ((json_t *)Json);
}
 
BOOLEAN
EFIAPI
JsonValueIsObject (
  IN    EDKII_JSON_VALUE  Json
  )
{
  return json_is_object ((json_t *)Json);
}
 
BOOLEAN
EFIAPI
JsonValueIsString (
  IN    EDKII_JSON_VALUE  Json
  )
{
  return json_is_string ((json_t *)Json);
}
 
BOOLEAN
EFIAPI
JsonValueIsInteger (
  IN    EDKII_JSON_VALUE  Json
  )
{
  return json_is_integer ((json_t *)Json);
}
 
BOOLEAN
EFIAPI
JsonValueIsNumber (
  IN    EDKII_JSON_VALUE  Json
  )
{
  return json_is_number ((json_t *)Json);
}
 
BOOLEAN
EFIAPI
JsonValueIsBoolean (
  IN    EDKII_JSON_VALUE  Json
  )
{
  return json_is_boolean ((json_t *)Json);
}
 
BOOLEAN
EFIAPI
JsonValueIsTrue (
  IN    EDKII_JSON_VALUE  Json
  )
{
  if (json_is_true ((json_t *)Json)) {
    return TRUE;
  }
 
  return FALSE;
}
 
BOOLEAN
EFIAPI
JsonValueIsFalse (
  IN    EDKII_JSON_VALUE  Json
  )
{
  if (json_is_false ((json_t *)Json)) {
    return TRUE;
  }
 
  return FALSE;
}
 
BOOLEAN
EFIAPI
JsonValueIsNull (
  IN    EDKII_JSON_VALUE  Json
  )
{
  return json_is_null ((json_t *)Json);
}
 
EDKII_JSON_ARRAY
EFIAPI
JsonValueGetArray (
  IN    EDKII_JSON_VALUE  Json
  )
{
  if ((Json == NULL) || !JsonValueIsArray (Json)) {
    return NULL;
  }
 
  return (EDKII_JSON_ARRAY)Json;
}
 
EDKII_JSON_OBJECT
EFIAPI
JsonValueGetObject (
  IN    EDKII_JSON_VALUE  Json
  )
{
  if ((Json == NULL) || !JsonValueIsObject (Json)) {
    return NULL;
  }
 
  return (EDKII_JSON_OBJECT)Json;
}
 
CONST CHAR8 *
EFIAPI
JsonValueGetAsciiString (
  IN    EDKII_JSON_VALUE  Json
  )
{
  CONST CHAR8  *AsciiStr;
  UINTN        Index;
 
  AsciiStr = json_string_value ((json_t *)Json);
  if (AsciiStr == NULL) {
    return NULL;
  }
 
  Index = 0;
  while (*(AsciiStr + Index) != '\0') {
    if (((*(AsciiStr + Index)) & 0x80) != 0x00) {
      return NULL;
    }
 
    Index++;
  }
 
  return AsciiStr;
}
 
CHAR16 *
EFIAPI
JsonValueGetUnicodeString (
  IN    EDKII_JSON_VALUE  Json
  )
{
  EFI_STATUS   Status;
  CONST CHAR8  *Utf8Str;
  CHAR16       *Ucs2Str;
 
  Ucs2Str = NULL;
  Utf8Str = json_string_value ((json_t *)Json);
  if (Utf8Str == NULL) {
    return NULL;
  }
 
  Status = UTF8StrToUCS2 ((CHAR8 *)Utf8Str, &Ucs2Str);
  if (EFI_ERROR (Status)) {
    return NULL;
  }
 
  return Ucs2Str;
}
 
INT64
EFIAPI
JsonValueGetInteger (
  IN    EDKII_JSON_VALUE  Json
  )
{
  ASSERT (Json != NULL && JsonValueIsInteger (Json));
  if ((Json == NULL) || !JsonValueIsInteger (Json)) {
    return 0;
  }
 
  return json_integer_value ((json_t *)Json);
}
 
BOOLEAN
EFIAPI
JsonValueGetBoolean (
  IN    EDKII_JSON_VALUE  Json
  )
{
  ASSERT (Json != NULL && JsonValueIsBoolean (Json));
  if ((Json == NULL) || !JsonValueIsBoolean (Json)) {
    return FALSE;
  }
 
  return json_is_true ((json_t *)Json);
}
 
CONST CHAR8 *
EFIAPI
JsonValueGetString (
  IN    EDKII_JSON_VALUE  Json
  )
{
  return json_string_value ((const json_t *)Json);
}
 
UINTN
EFIAPI
JsonObjectSize (
  IN    EDKII_JSON_OBJECT  JsonObject
  )
{
  return json_object_size ((json_t *)JsonObject);
}
 
EFI_STATUS
EFIAPI
JsonObjectClear (
  IN    EDKII_JSON_OBJECT  JsonObject
  )
{
  if (json_object_clear ((json_t *)JsonObject) != 0) {
    return EFI_ABORTED;
  }
 
  return EFI_SUCCESS;
}
 
CHAR8 **
JsonObjectGetKeys (
  IN    EDKII_JSON_OBJECT  JsonObj,
  OUT   UINTN              *KeyCount
  )
{
  UINTN             Index;
  CONST CHAR8       **KeyArray;
  CONST CHAR8       *Key;
  EDKII_JSON_VALUE  Value;
 
  if ((JsonObj == NULL) || (KeyCount == NULL)) {
    return NULL;
  }
 
  Index = 0;
  json_object_foreach (JsonObj, Key, Value) {
    Index++;
  }
  if (Index == 0) {
    *KeyCount = 0;
    return NULL;
  }
 
  *KeyCount = Index;
  KeyArray  = (CONST CHAR8 **)AllocateZeroPool (*KeyCount * sizeof (CHAR8 *));
  if (KeyArray == NULL) {
    return NULL;
  }
 
  Key   = NULL;
  Value = NULL;
  Index = 0;
  json_object_foreach ((json_t *)JsonObj, Key, Value) {
    KeyArray[Index] = Key;
    Index++;
  }
 
  return (CHAR8 **)KeyArray;
}
 
EDKII_JSON_VALUE
EFIAPI
JsonObjectGetValue (
  IN    CONST EDKII_JSON_OBJECT  JsonObj,
  IN    CONST CHAR8              *Key
  )
{
  return (EDKII_JSON_VALUE)json_object_get ((const json_t *)JsonObj, (const char *)Key);
}
 
EFI_STATUS
EFIAPI
JsonObjectSetValue (
  IN    EDKII_JSON_OBJECT  JsonObj,
  IN    CONST CHAR8        *Key,
  IN    EDKII_JSON_VALUE   Json
  )
{
  if (json_object_set ((json_t *)JsonObj, Key, (json_t *)Json) != 0) {
    return EFI_ABORTED;
  } else {
    return EFI_SUCCESS;
  }
}
 
EFI_STATUS
EFIAPI
JsonObjectDelete (
  IN    EDKII_JSON_OBJECT  JsonObj,
  IN    CONST CHAR8        *Key
  )
{
  if (json_object_del ((json_t *)JsonObj, (const char *)Key) != 0) {
    return EFI_ABORTED;
  } else {
    return EFI_SUCCESS;
  }
}
 
UINTN
EFIAPI
JsonArrayCount (
  IN    EDKII_JSON_ARRAY  JsonArray
  )
{
  return json_array_size ((json_t *)JsonArray);
}
 
EDKII_JSON_VALUE
EFIAPI
JsonArrayGetValue (
  IN    EDKII_JSON_ARRAY  JsonArray,
  IN    UINTN             Index
  )
{
  return (EDKII_JSON_VALUE)json_array_get ((json_t *)JsonArray, Index);
}
 
EFI_STATUS
EFIAPI
JsonArrayAppendValue (
  IN    EDKII_JSON_ARRAY  JsonArray,
  IN    EDKII_JSON_VALUE  Json
  )
{
  if (json_array_append ((json_t *)JsonArray, (json_t *)Json) != 0) {
    return EFI_ABORTED;
  } else {
    return EFI_SUCCESS;
  }
}
 
EFI_STATUS
EFIAPI
JsonArrayRemoveValue (
  IN    EDKII_JSON_ARRAY  JsonArray,
  IN    UINTN             Index
  )
{
  if (json_array_remove ((json_t *)JsonArray, Index) != 0) {
    return EFI_ABORTED;
  } else {
    return EFI_SUCCESS;
  }
}
 
CHAR8 *
EFIAPI
JsonDumpString (
  IN    EDKII_JSON_VALUE  JsonValue,
  IN    UINTN             Flags
  )
{
  if (JsonValue == NULL) {
    return NULL;
  }
 
  return json_dumps ((json_t *)JsonValue, Flags);
}
 
EDKII_JSON_VALUE
EFIAPI
JsonLoadString (
  IN    CONST CHAR8       *String,
  IN    UINT64            Flags,
  IN    EDKII_JSON_ERROR  *Error
  )
{
  return (EDKII_JSON_VALUE)json_loads ((const char *)String, Flags, (json_error_t *)Error);
}
 
EDKII_JSON_VALUE
EFIAPI
JsonLoadBuffer (
  IN    CONST CHAR8        *Buffer,
  IN    UINTN              BufferLen,
  IN    UINTN              Flags,
  IN OUT EDKII_JSON_ERROR  *Error
  )
{
  return json_loadb (Buffer, BufferLen, Flags, (json_error_t *)Error);
}
 
VOID
EFIAPI
JsonDecreaseReference (
  IN EDKII_JSON_VALUE  JsonValue
  )
{
  json_decref (JsonValue);
}
 
EDKII_JSON_VALUE
EFIAPI
JsonIncreaseReference (
  IN EDKII_JSON_VALUE  JsonValue
  )
{
  return json_incref (JsonValue);
}
 
VOID *
EFIAPI
JsonObjectIterator (
  IN EDKII_JSON_VALUE  JsonValue
  )
{
  return json_object_iter (JsonValue);
}
 
EDKII_JSON_VALUE
EFIAPI
JsonObjectIteratorValue (
  IN VOID  *Iterator
  )
{
  return json_object_iter_value (Iterator);
}
 
VOID *
EFIAPI
JsonObjectIteratorNext (
  IN EDKII_JSON_VALUE  JsonValue,
  IN VOID              *Iterator
  )
{
  return json_object_iter_next (JsonValue, Iterator);
}
 
CHAR8 *
EFIAPI
JsonObjectIteratorKey (
  IN VOID  *Iterator
  )
{
  return (CHAR8 *)json_object_iter_key (Iterator);
}
 
VOID *
EFIAPI
JsonObjectKeyToIterator (
  IN CHAR8  *Key
  )
{
  return json_object_key_to_iter (Key);
}
 
EDKII_JSON_TYPE
EFIAPI
JsonGetType (
  IN EDKII_JSON_VALUE  JsonValue
  )
{
  return (EDKII_JSON_TYPE)(((json_t *)JsonValue)->type);
}
 
EFI_STATUS
EFIAPI
JsonLibConstructor (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  //
  // hashtable_seed is initalized by current time while JsonLib is loaded.
  // Due to above mechanism, hashtable_seed will be different in each individual
  // UEFI driver. As the result, the hash of same key in different UEFI driver
  // would be different. This breaks JsonObjectGetValue() because
  // JsonObjectGetValue() won't be able to find corresponding JSON value if
  // this EDKII_JSON_VALUE is created by another UEFI driver.
  //
  // Initial the seed to a fixed magic value for JsonLib to be working in all
  // UEFI drivers. This fixed number will be removed after the protocol version
  // of JsonLib is implemented in the future.
  //
  hashtable_seed = 0xFDAE2143;
 
  return EFI_SUCCESS;
}