1. Change the UTF-16 languages.ini to UTF-8 languages.json

2. The update button is available even if data corrupted in VTOYEFI partition.
3. Set the default focus to No when you click Install button in Ventoy2Disk.exe.
4. Fix a BUG when booting Windows VHD(x) with the latest ventoy_vhdboot.img.
5. Support boot Windows VHD(x) files in local disk.

Ventoy2Disk/Ventoy2Disk/Language.h

@@ -101,13 +101,19 @@ typedef enum OPT_SUBMENU
 #define VTOY_MENU_LANGUAGE_BEGIN  0xB000
 
 
-#define VENTOY_LANGUAGE_INI  TEXT(".\\ventoy\\languages.ini")
+#define VENTOY_LANGUAGE_INI     TEXT(".\\ventoy\\languages.ini")
+#define VENTOY_LANGUAGE_JSON    TEXT(".\\ventoy\\languages.json")
+#define VENTOY_LANGUAGE_INI_A   ".\\ventoy\\languages.ini"
+#define VENTOY_LANGUAGE_JSON_A  ".\\ventoy\\languages.json"
+
 #define VENTOY_CFG_INI     TEXT(".\\Ventoy2Disk.ini")
 #define VENTOY_CFG_INI_A   ".\\Ventoy2Disk.ini"
 #define VENTOY_MAX_LANGUAGE	 200
 
 #define GET_INI_STRING(Section, Key, Buf) GetPrivateProfileString(Section, Key, TEXT("#"), Buf, sizeof(Buf), VENTOY_LANGUAGE_INI)
 
+
+
 typedef struct VENTOY_LANGUAGE
 {
 	WCHAR Name[128];

Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.c

@@ -283,6 +283,12 @@ static int FilterPhysicalDrive(PHY_DRIVE_INFO *pDriveList, DWORD DriveCount)
             CurDrive->PartStyle = (MBR.PartTbl[0].FsFlag == 0xEE) ? 1 : 0;
             GetVentoyVerInPhyDrive(CurDrive, Part2StartSector, CurDrive->VentoyVersion, sizeof(CurDrive->VentoyVersion), &(CurDrive->SecureBootSupport));
             Log("PhyDrive %d is Ventoy Disk ver:%s SecureBoot:%u", CurDrive->PhyDrive, CurDrive->VentoyVersion, CurDrive->SecureBootSupport);
+
+            if (CurDrive->VentoyVersion[0] == 0)
+            {
+                CurDrive->VentoyVersion[0] = '?';
+                Log("Unknown Ventoy Version");
+            }
         }
     }
 

Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.h

@@ -148,7 +148,7 @@ typedef struct PHY_DRIVE_INFO
     STORAGE_BUS_TYPE BusType;
 
     CHAR DriveLetters[64];
-
+   
     CHAR VentoyVersion[32];
 
     BOOL SecureBootSupport;

Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj

@@ -110,6 +110,7 @@
     <ClCompile Include="process.c" />
     <ClCompile Include="Utility.c" />
     <ClCompile Include="Ventoy2Disk.c" />
+    <ClCompile Include="VentoyJson.c" />
     <ClCompile Include="WinDialog.c" />
     <ClCompile Include="xz-embedded-20130513\linux\lib\decompress_unxz.c" />
   </ItemGroup>
@@ -133,6 +134,7 @@
     <ClInclude Include="process.h" />
     <ClInclude Include="resource.h" />
     <ClInclude Include="Ventoy2Disk.h" />
+    <ClInclude Include="VentoyJson.h" />
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="Ventoy2Disk.rc" />

Ventoy2Disk/Ventoy2Disk/Ventoy2Disk.vcxproj.filters

@@ -78,6 +78,9 @@
     <ClCompile Include="crc32.c">
       <Filter>源文件</Filter>
     </ClCompile>
+    <ClCompile Include="VentoyJson.c">
+      <Filter>源文件</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Ventoy2Disk.h">
@@ -137,6 +140,9 @@
     <ClInclude Include="process.h">
       <Filter>头文件</Filter>
     </ClInclude>
+    <ClInclude Include="VentoyJson.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="Ventoy2Disk.rc">

Ventoy2Disk/Ventoy2Disk/VentoyJson.c

@@ -0,0 +1,771 @@
+/******************************************************************************
+ * VentoyJson.c
+ *
+ * Copyright (c) 2021, longpanda <admin@ventoy.net>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef FOR_VTOY_JSON_CHECK
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#else
+#include <Windows.h>
+#include "Ventoy2Disk.h"
+#endif
+
+#include "VentoyJson.h"
+
+static void vtoy_json_free(VTOY_JSON *pstJsonHead)
+{
+    VTOY_JSON *pstNext = NULL;
+
+    while (NULL != pstJsonHead)
+    {
+        pstNext = pstJsonHead->pstNext;
+        if ((pstJsonHead->enDataType < JSON_TYPE_BUTT) && (NULL != pstJsonHead->pstChild))
+        {
+            vtoy_json_free(pstJsonHead->pstChild);
+        }
+
+        free(pstJsonHead);
+        pstJsonHead = pstNext;
+    }
+
+    return;
+}
+
+static char *vtoy_json_skip(const char *pcData)
+{
+    while ((NULL != pcData) && ('\0' != *pcData) && (*pcData <= 32))
+    {
+        pcData++;
+    }
+
+    return (char *)pcData;
+}
+
+VTOY_JSON *vtoy_json_find_item
+(
+    VTOY_JSON *pstJson,
+    JSON_TYPE  enDataType,
+    const char *szKey
+)
+{
+    while (NULL != pstJson)
+    {
+        if ((enDataType == pstJson->enDataType) && 
+            (0 == strcmp(szKey, pstJson->pcName)))
+        {
+            return pstJson;
+        }
+        pstJson = pstJson->pstNext;
+    }
+    
+    return NULL;
+}
+
+static int vtoy_json_parse_number
+(
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    unsigned long Value;
+
+    Value = strtoul(pcData, (char **)ppcEnd, 10);
+    if (*ppcEnd == pcData)
+    {
+        Log("Failed to parse json number %s.", pcData);
+        return JSON_FAILED;
+    }
+
+    pstJson->enDataType = JSON_TYPE_NUMBER;
+    pstJson->unData.lValue = Value;
+    
+    return JSON_SUCCESS;
+}
+
+static int vtoy_json_parse_string
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    UINT32 uiLen = 0;
+    const char *pcPos = NULL;
+    const char *pcTmp = pcData + 1;
+    
+    *ppcEnd = pcData;
+
+    if ('\"' != *pcData)
+    {
+        return JSON_FAILED;
+    }
+
+    pcPos = strchr(pcTmp, '\"');
+    if ((NULL == pcPos) || (pcPos < pcTmp))
+    {
+        Log("Invalid string %s.", pcData);
+        return JSON_FAILED;
+    }
+
+    *ppcEnd = pcPos + 1;
+    uiLen = (UINT32)(unsigned long)(pcPos - pcTmp);    
+    
+    pstJson->enDataType = JSON_TYPE_STRING;
+    pstJson->unData.pcStrVal = pcNewStart + (pcTmp - pcRawStart);
+    pstJson->unData.pcStrVal[uiLen] = '\0';
+    
+    return JSON_SUCCESS;
+}
+
+static int vtoy_json_parse_array
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    int Ret = JSON_SUCCESS;
+    VTOY_JSON *pstJsonChild = NULL;
+    VTOY_JSON *pstJsonItem = NULL;
+    const char *pcTmp = pcData + 1;
+
+    *ppcEnd = pcData;
+    pstJson->enDataType = JSON_TYPE_ARRAY;
+
+    if ('[' != *pcData)
+    {
+        return JSON_FAILED;
+    }
+
+    pcTmp = vtoy_json_skip(pcTmp);
+
+    if (']' == *pcTmp)
+    {
+        *ppcEnd = pcTmp + 1;
+        return JSON_SUCCESS;
+    }
+
+    JSON_NEW_ITEM(pstJson->pstChild, JSON_FAILED);
+
+    Ret = vtoy_json_parse_value(pcNewStart, pcRawStart, pstJson->pstChild, pcTmp, ppcEnd);
+    if (JSON_SUCCESS != Ret)
+    {
+        Log("Failed to parse array child.");
+        return JSON_FAILED;
+    }
+
+    pstJsonChild = pstJson->pstChild;
+    pcTmp = vtoy_json_skip(*ppcEnd);
+    while ((NULL != pcTmp) && (',' == *pcTmp))
+    {
+        JSON_NEW_ITEM(pstJsonItem, JSON_FAILED);
+        pstJsonChild->pstNext = pstJsonItem;
+        pstJsonItem->pstPrev = pstJsonChild;
+        pstJsonChild = pstJsonItem;
+
+        Ret = vtoy_json_parse_value(pcNewStart, pcRawStart, pstJsonChild, vtoy_json_skip(pcTmp + 1), ppcEnd);
+        if (JSON_SUCCESS != Ret)
+        {
+            Log("Failed to parse array child.");
+            return JSON_FAILED;
+        }
+        pcTmp = vtoy_json_skip(*ppcEnd);
+    }
+
+    if ((NULL != pcTmp) && (']' == *pcTmp))
+    {
+        *ppcEnd = pcTmp + 1;
+        return JSON_SUCCESS;
+    }
+    else
+    {
+        *ppcEnd = pcTmp;
+        return JSON_FAILED;
+    }
+}
+
+static int vtoy_json_parse_object
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    int Ret = JSON_SUCCESS;
+    VTOY_JSON *pstJsonChild = NULL;
+    VTOY_JSON *pstJsonItem = NULL;
+    const char *pcTmp = pcData + 1;
+
+    *ppcEnd = pcData;
+    pstJson->enDataType = JSON_TYPE_OBJECT;
+
+    if ('{' != *pcData)
+    {
+        return JSON_FAILED;
+    }
+
+    pcTmp = vtoy_json_skip(pcTmp);
+    if ('}' == *pcTmp)
+    {
+        *ppcEnd = pcTmp + 1;
+        return JSON_SUCCESS;
+    }
+
+    JSON_NEW_ITEM(pstJson->pstChild, JSON_FAILED);
+
+    Ret = vtoy_json_parse_string(pcNewStart, pcRawStart, pstJson->pstChild, pcTmp, ppcEnd);
+    if (JSON_SUCCESS != Ret)
+    {
+        Log("Failed to parse array child.");
+        return JSON_FAILED;
+    }
+
+    pstJsonChild = pstJson->pstChild;
+    pstJsonChild->pcName = pstJsonChild->unData.pcStrVal;
+    pstJsonChild->unData.pcStrVal = NULL;
+
+    pcTmp = vtoy_json_skip(*ppcEnd);
+    if ((NULL == pcTmp) || (':' != *pcTmp))
+    {
+        *ppcEnd = pcTmp;
+        return JSON_FAILED;
+    }
+
+    Ret = vtoy_json_parse_value(pcNewStart, pcRawStart, pstJsonChild, vtoy_json_skip(pcTmp + 1), ppcEnd);
+    if (JSON_SUCCESS != Ret)
+    {
+        Log("Failed to parse array child.");
+        return JSON_FAILED;
+    }
+
+    pcTmp = vtoy_json_skip(*ppcEnd);
+    while ((NULL != pcTmp) && (',' == *pcTmp))
+    {
+        JSON_NEW_ITEM(pstJsonItem, JSON_FAILED);
+        pstJsonChild->pstNext = pstJsonItem;
+        pstJsonItem->pstPrev = pstJsonChild;
+        pstJsonChild = pstJsonItem;
+
+        Ret = vtoy_json_parse_string(pcNewStart, pcRawStart, pstJsonChild, vtoy_json_skip(pcTmp + 1), ppcEnd);
+        if (JSON_SUCCESS != Ret)
+        {
+            Log("Failed to parse array child.");
+            return JSON_FAILED;
+        }
+
+        pcTmp = vtoy_json_skip(*ppcEnd);
+        pstJsonChild->pcName = pstJsonChild->unData.pcStrVal;
+        pstJsonChild->unData.pcStrVal = NULL;
+        if ((NULL == pcTmp) || (':' != *pcTmp))
+        {
+            *ppcEnd = pcTmp;
+            return JSON_FAILED;
+        }
+
+        Ret = vtoy_json_parse_value(pcNewStart, pcRawStart, pstJsonChild, vtoy_json_skip(pcTmp + 1), ppcEnd);
+        if (JSON_SUCCESS != Ret)
+        {
+            Log("Failed to parse array child.");
+            return JSON_FAILED;
+        }
+
+        pcTmp = vtoy_json_skip(*ppcEnd);
+    }
+
+    if ((NULL != pcTmp) && ('}' == *pcTmp))
+    {
+        *ppcEnd = pcTmp + 1;
+        return JSON_SUCCESS;
+    }
+    else
+    {
+        *ppcEnd = pcTmp;
+        return JSON_FAILED;
+    }
+}
+
+int vtoy_json_parse_value
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+)
+{
+    pcData = vtoy_json_skip(pcData);
+    
+    switch (*pcData)
+    {
+        case 'n':
+        {
+            if (0 == strncmp(pcData, "null", 4))
+            {
+                pstJson->enDataType = JSON_TYPE_NULL;
+                *ppcEnd = pcData + 4;
+                return JSON_SUCCESS;
+            }
+            break;
+        }
+        case 'f':
+        {
+            if (0 == strncmp(pcData, "false", 5))
+            {
+                pstJson->enDataType = JSON_TYPE_BOOL;
+                pstJson->unData.lValue = 0;
+                *ppcEnd = pcData + 5;
+                return JSON_SUCCESS;
+            }
+            break;
+        }
+        case 't':
+        {
+            if (0 == strncmp(pcData, "true", 4))
+            {
+                pstJson->enDataType = JSON_TYPE_BOOL;
+                pstJson->unData.lValue = 1;
+                *ppcEnd = pcData + 4;
+                return JSON_SUCCESS;
+            }
+            break;
+        }
+        case '\"':
+        {
+            return vtoy_json_parse_string(pcNewStart, pcRawStart, pstJson, pcData, ppcEnd);
+        }
+        case '[':
+        {
+            return vtoy_json_parse_array(pcNewStart, pcRawStart, pstJson, pcData, ppcEnd);
+        }
+        case '{':
+        {
+            return vtoy_json_parse_object(pcNewStart, pcRawStart, pstJson, pcData, ppcEnd);
+        }
+        case '-':
+        {
+            return vtoy_json_parse_number(pstJson, pcData, ppcEnd);
+        }
+        default :
+        {
+            if (*pcData >= '0' && *pcData <= '9')
+            {
+                return vtoy_json_parse_number(pstJson, pcData, ppcEnd);
+            }
+        }
+    }
+
+    *ppcEnd = pcData;
+    Log("Invalid json data %u.", (UINT8)(*pcData));
+    return JSON_FAILED;
+}
+
+VTOY_JSON * vtoy_json_create(void)
+{
+    VTOY_JSON *pstJson = NULL;
+
+    pstJson = (VTOY_JSON *)malloc(sizeof(VTOY_JSON));
+    if (NULL == pstJson)
+    {
+        return NULL;
+    }
+    memset(pstJson, 0, sizeof(VTOY_JSON));
+    return pstJson;
+}
+
+int vtoy_json_parse(VTOY_JSON *pstJson, const char *szJsonData)
+{
+    UINT32 uiMemSize = 0;
+    int Ret = JSON_SUCCESS;
+    char *pcNewBuf = NULL;
+    const char *pcEnd = NULL;
+
+    uiMemSize = strlen(szJsonData) + 1;
+    pcNewBuf = (char *)malloc(uiMemSize);
+    if (NULL == pcNewBuf)
+    {
+        Log("Failed to alloc new buf.");
+        return JSON_FAILED;
+    }
+    memcpy(pcNewBuf, szJsonData, uiMemSize);
+    pcNewBuf[uiMemSize - 1] = 0;
+
+    Ret = vtoy_json_parse_value(pcNewBuf, (char *)szJsonData, pstJson, szJsonData, &pcEnd);
+    if (JSON_SUCCESS != Ret)
+    {
+        Log("Failed to parse json data start=%p, end=%p", szJsonData, pcEnd);
+        return JSON_FAILED;
+    }
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_scan_parse
+(
+    const VTOY_JSON    *pstJson,
+    UINT32       uiParseNum,
+    JSON_PARSE         *pstJsonParse
+)
+{   
+    UINT32 i = 0;
+    const VTOY_JSON *pstJsonCur = NULL;
+    JSON_PARSE *pstCurParse = NULL;
+
+    for (pstJsonCur = pstJson; NULL != pstJsonCur; pstJsonCur = pstJsonCur->pstNext)
+    {
+        if ((JSON_TYPE_OBJECT == pstJsonCur->enDataType) ||
+            (JSON_TYPE_ARRAY == pstJsonCur->enDataType))
+        {
+            continue;
+        }
+
+        for (i = 0, pstCurParse = NULL; i < uiParseNum; i++)
+        {
+            if (0 == strcmp(pstJsonParse[i].pcKey, pstJsonCur->pcName))
+            {   
+                pstCurParse = pstJsonParse + i;
+                break;
+            }
+        }
+
+        if (NULL == pstCurParse)
+        {
+            continue;
+        }
+    
+        switch (pstJsonCur->enDataType)
+        {
+            case JSON_TYPE_NUMBER:
+            {
+                if (sizeof(UINT32) == pstCurParse->uiBufSize)
+                {
+                    *(UINT32 *)(pstCurParse->pDataBuf) = (UINT32)pstJsonCur->unData.lValue;
+                }
+                else if (sizeof(UINT16) == pstCurParse->uiBufSize)
+                {
+                    *(UINT16 *)(pstCurParse->pDataBuf) = (UINT16)pstJsonCur->unData.lValue;
+                }
+                else if (sizeof(UINT8) == pstCurParse->uiBufSize)
+                {
+                    *(UINT8 *)(pstCurParse->pDataBuf) = (UINT8)pstJsonCur->unData.lValue;
+                }
+                else if ((pstCurParse->uiBufSize > sizeof(UINT64)))
+                {
+                    sprintf_s((char *)pstCurParse->pDataBuf, pstCurParse->uiBufSize, "%llu",
+                        (unsigned long long)(pstJsonCur->unData.lValue));
+                }
+                else
+                {
+                    Log("Invalid number data buf size %u.", pstCurParse->uiBufSize);
+                }
+                break;
+            }
+            case JSON_TYPE_STRING:
+            {
+                strcpy_s((char *)pstCurParse->pDataBuf, pstCurParse->uiBufSize, pstJsonCur->unData.pcStrVal);
+                break;
+            }
+            case JSON_TYPE_BOOL:
+            {
+                *(UINT8 *)(pstCurParse->pDataBuf) = (pstJsonCur->unData.lValue) > 0 ? 1 : 0;
+                break;
+            }
+            default :
+            {
+                break;
+            }
+        }
+    }
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_scan_array
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstArrayItem
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_ARRAY, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *ppstArrayItem = pstJsonItem;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_scan_array_ex
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstArrayItem
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_ARRAY, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+    
+    *ppstArrayItem = pstJsonItem->pstChild;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_scan_object
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstObjectItem
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_OBJECT, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *ppstObjectItem = pstJsonItem;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_int
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    int *piValue
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_NUMBER, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *piValue = (int)pstJsonItem->unData.lValue;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_uint
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    UINT32 *puiValue
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_NUMBER, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *puiValue = (UINT32)pstJsonItem->unData.lValue;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_uint64
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    UINT64 *pui64Value
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_NUMBER, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *pui64Value = (UINT64)pstJsonItem->unData.lValue;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_bool
+(
+    VTOY_JSON *pstJson,
+    const char *szKey, 
+    UINT8 *pbValue
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_BOOL, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    *pbValue = pstJsonItem->unData.lValue > 0 ? 1 : 0;
+
+    return JSON_SUCCESS;
+}
+
+int vtoy_json_get_string
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     UINT32  uiBufLen,
+     char *pcBuf
+)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+    
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_STRING, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return JSON_NOT_FOUND;
+    }
+
+    strcpy_s(pcBuf, uiBufLen, pstJsonItem->unData.pcStrVal);
+
+    return JSON_SUCCESS;
+}
+
+const char * vtoy_json_get_string_ex(VTOY_JSON *pstJson,  const char *szKey)
+{
+    VTOY_JSON *pstJsonItem = NULL;
+
+    if ((NULL == pstJson) || (NULL == szKey))
+    {
+        return NULL;
+    }
+
+    pstJsonItem = vtoy_json_find_item(pstJson, JSON_TYPE_STRING, szKey);
+    if (NULL == pstJsonItem)
+    {
+        Log("Key %s is not found in json data.", szKey);
+        return NULL;
+    }
+
+    return pstJsonItem->unData.pcStrVal;
+}
+
+int vtoy_json_destroy(VTOY_JSON *pstJson)
+{
+    if (NULL == pstJson)
+    {   
+        return JSON_SUCCESS;
+    }
+
+    if (NULL != pstJson->pstChild)
+    {
+        vtoy_json_free(pstJson->pstChild);
+    }
+
+    if (NULL != pstJson->pstNext)
+    {
+        vtoy_json_free(pstJson->pstNext);
+    }
+
+    free(pstJson);
+    
+    return JSON_SUCCESS;
+}
+
+
+#ifdef FOR_VTOY_JSON_CHECK
+
+int main(int argc, char**argv)
+{
+    int ret = 1;
+    int FileSize;
+    FILE *fp;
+    void *Data = NULL;
+    VTOY_JSON *json = NULL;
+
+    fp = fopen(argv[1], "rb");
+    if (!fp)
+    {
+        Log("Failed to open %s\n", argv[1]);
+        goto out;
+    }
+
+    fseek(fp, 0, SEEK_END);
+    FileSize = (int)ftell(fp);
+    fseek(fp, 0, SEEK_SET);
+
+    Data = malloc(FileSize + 4);
+    if (!Data)
+    {
+        Log("Failed to malloc %d\n", FileSize + 4);
+        goto out;
+    }
+    *((char *)Data + FileSize) = 0;
+
+    fread(Data, 1, FileSize, fp);
+
+    json = vtoy_json_create();
+    if (!json)
+    {
+        Log("Failed vtoy_json_create\n");
+        goto out;
+    }
+
+    if (vtoy_json_parse(json, (char *)Data) != JSON_SUCCESS)
+    {
+        goto out;
+    }
+
+    ret = 0;
+
+out:
+    if (fp) fclose(fp);
+    if (Data) free(Data);
+    if (json) vtoy_json_destroy(json);
+
+    printf("\n");
+    return ret;
+}
+
+#endif

Ventoy2Disk/Ventoy2Disk/VentoyJson.h

@@ -0,0 +1,164 @@
+/******************************************************************************
+ * VentoyJson.h
+ *
+ * Copyright (c) 2021, longpanda <admin@ventoy.net>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef __VENTOY_JSON_H__
+#define __VENTOY_JSON_H__
+
+#ifdef FOR_VTOY_JSON_CHECK
+typedef unsigned char      UINT8;
+typedef unsigned short     UINT16;
+typedef unsigned int       UINT32;
+typedef unsigned long long UINT64;
+
+#define Log printf
+#define strcpy_s(a, b, c) strncpy(a, c, b)
+#define sprintf_s snprintf
+#endif
+
+#define JSON_SUCCESS    0
+#define JSON_FAILED     1
+#define JSON_NOT_FOUND  2
+
+typedef enum _JSON_TYPE
+{
+    JSON_TYPE_NUMBER = 0,
+    JSON_TYPE_STRING,
+    JSON_TYPE_BOOL,
+    JSON_TYPE_ARRAY,
+    JSON_TYPE_OBJECT,
+    JSON_TYPE_NULL,
+    JSON_TYPE_BUTT
+}JSON_TYPE;
+
+
+typedef struct _VTOY_JSON
+{
+    struct _VTOY_JSON *pstPrev;
+    struct _VTOY_JSON *pstNext;
+    struct _VTOY_JSON *pstChild;
+
+    JSON_TYPE enDataType;
+    union 
+    {
+        char  *pcStrVal;
+        int   iNumVal;
+        UINT64 lValue;
+    }unData;
+
+    char *pcName;
+}VTOY_JSON;
+
+typedef struct _JSON_PARSE
+{
+    char *pcKey;
+    void *pDataBuf;
+    UINT32  uiBufSize;
+}JSON_PARSE;
+
+#define JSON_NEW_ITEM(pstJson, ret) \
+{ \
+    (pstJson) = (VTOY_JSON *)malloc(sizeof(VTOY_JSON)); \
+    if (NULL == (pstJson)) \
+    { \
+        Log("Failed to alloc memory for json.\n"); \
+        return (ret); \
+    } \
+    memset((pstJson), 0, sizeof(VTOY_JSON));\
+}
+
+VTOY_JSON *vtoy_json_find_item
+(
+    VTOY_JSON *pstJson,
+    JSON_TYPE  enDataType,
+    const char *szKey
+);
+int vtoy_json_parse_value
+(
+    char *pcNewStart,
+    char *pcRawStart,
+    VTOY_JSON *pstJson, 
+    const char *pcData,
+    const char **ppcEnd
+);
+VTOY_JSON * vtoy_json_create(void);
+int vtoy_json_parse(VTOY_JSON *pstJson, const char *szJsonData);
+
+int vtoy_json_scan_parse
+(
+    const VTOY_JSON    *pstJson,
+    UINT32              uiParseNum,
+    JSON_PARSE         *pstJsonParse
+);
+
+int vtoy_json_scan_array
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstArrayItem
+);
+
+int vtoy_json_scan_array_ex
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     VTOY_JSON **ppstArrayItem
+);
+int vtoy_json_scan_object
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+    VTOY_JSON **ppstObjectItem
+);
+int vtoy_json_get_int
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    int *piValue
+);
+int vtoy_json_get_uint
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    UINT32     *puiValue
+);
+int vtoy_json_get_uint64
+(
+    VTOY_JSON *pstJson, 
+    const char *szKey, 
+    UINT64 *pui64Value
+);
+int vtoy_json_get_bool
+(
+    VTOY_JSON *pstJson,
+    const char *szKey, 
+    UINT8 *pbValue
+);
+int vtoy_json_get_string
+(
+     VTOY_JSON *pstJson, 
+     const char *szKey, 
+     UINT32  uiBufLen,
+     char *pcBuf
+);
+const char * vtoy_json_get_string_ex(VTOY_JSON *pstJson,  const char *szKey);
+int vtoy_json_destroy(VTOY_JSON *pstJson);
+
+#endif /* __VENTOY_JSON_H__ */
+