/* $Id: inifile.cpp 99758 2023-05-11 21:37:59Z vboxsync $ */ /** @file * IPRT - INI-file parser. */ /* * Copyright (C) 2017-2023 Oracle and/or its affiliates. * * This file is part of VirtualBox base platform packages, as * available from https://www.virtualbox.org. * * 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, in version 3 of the * License. * * 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 . * * The contents of this file may alternatively be used under the terms * of the Common Development and Distribution License Version 1.0 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included * in the VirtualBox distribution, in which case the provisions of the * CDDL are applicable instead of those of the GPL. * * You may elect to license modified versions of this file under the * terms and conditions of either the GPL or the CDDL or both. * * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0 */ /********************************************************************************************************************************* * Header Files * *********************************************************************************************************************************/ #include #include "internal/iprt.h" #include #include #include #include #include #include #include #include #include #include "internal/magics.h" /********************************************************************************************************************************* * Defined Constants And Macros * *********************************************************************************************************************************/ /** @def RTINIFILE_MAX_SIZE * The maximum INI-file size we accept loading. */ #if ARCH_BITS > 32 # define RTINIFILE_MAX_SIZE (_64M - 2U) #elif ARCH_BITS > 16 # define RTINIFILE_MAX_SIZE (_16M - 2U) #else # define RTINIFILE_MAX_SIZE (_64K - 2U) #endif /** @def RTINIFILE_MAX_SECTIONS * The maximum number of sections we accept in an INI-file. */ #if ARCH_BITS > 32 # define RTINIFILE_MAX_SECTIONS (_1M) #elif ARCH_BITS > 16 # define RTINIFILE_MAX_SECTIONS (_256K) #else # define RTINIFILE_MAX_SECTIONS (_1K) #endif /********************************************************************************************************************************* * Structures and Typedefs * *********************************************************************************************************************************/ /** * File encoding types. */ typedef enum RTINIFILEENCODING { /** The customary invalid zero value. */ RTINIFILEENCODING_INVALID = 0, /** We treat this as latin-1. */ RTINIFILEENCODING_ANSI, /** UTF-8. */ RTINIFILEENCODING_UTF8, /** Little endian UTF-16. */ RTINIFILEENCODING_UTF16LE, /** Big endian UTF-16. */ RTINIFILEENCODING_UTF16BE, /** End of valid encoding types. */ RTINIFILEENCODING_END } RTINIFILEENCODING; /** * Preparsed section info. */ typedef struct RTINIFILESECTION { /** The section name offset (byte). */ uint32_t offName; /** The section length in bytes starting with the name. */ uint32_t cchSection; /** The UTF-8 length of the section name. */ uint32_t cchName; /** Offset into the section where to start looking for values. */ uint32_t cchSkipToValues : 24; /** @todo use 4 bits for flags and stuff. like escaped name. */ } RTINIFILESECTION; /** Pointer to preparsed section info. */ typedef RTINIFILESECTION *PRTINIFILESECTION; /** * INI-file instance data. */ typedef struct RTINIFILEINT { /** Magic value (RTINIFILEINT_MAGIC). */ uint32_t u32Magic; /** Reference counter. */ uint32_t volatile cRefs; /** The file we're working on. */ RTVFSFILE hVfsFile; /** Flags, RTINIFILE_F_XXX. */ uint32_t fFlags; /** The original file encoding. */ RTINIFILEENCODING enmEncoding; /** Pointer to the file content (converted to UTF-8). */ char *pszFile; /** The file size. */ uint32_t cbFile; /** Number of sections. */ uint32_t cSections; /** Sections in the loaded file. */ PRTINIFILESECTION paSections; } RTINIFILEINT; /** Pointer to an INI-file instance. */ typedef RTINIFILEINT *PRTINIFILEINT; static int rtIniFileLoad(PRTINIFILEINT pThis) { /* * Load the entire file into memory, ensuring two terminating zeros. */ uint64_t cbFile; int rc = RTVfsFileQuerySize(pThis->hVfsFile, &cbFile); AssertRCReturn(rc, rc); if (cbFile > RTINIFILE_MAX_SIZE) return VERR_TOO_MUCH_DATA; if (cbFile == 0) return VINF_SUCCESS; /* Nothing to do. */ pThis->cbFile = (uint32_t)cbFile; pThis->pszFile = (char *)RTMemAllocZ(pThis->cbFile + 2); if (!pThis->pszFile) return VERR_NO_MEMORY; rc = RTVfsFileReadAt(pThis->hVfsFile, 0, pThis->pszFile, pThis->cbFile, NULL); AssertRCReturn(rc, rc); /* * Detect encoding and convert to BOM prefixed UTF-8. */ if ( (uint8_t)pThis->pszFile[0] == UINT8_C(0xef) && (uint8_t)pThis->pszFile[1] == UINT8_C(0xbb) && (uint8_t)pThis->pszFile[2] == UINT8_C(0xbf)) { pThis->enmEncoding = RTINIFILEENCODING_UTF8; rc = RTStrValidateEncoding(&pThis->pszFile[3]); if (RT_FAILURE(rc)) return rc; } else { size_t cchUtf8; if ( (uint8_t)pThis->pszFile[0] == UINT8_C(0xfe) && (uint8_t)pThis->pszFile[1] == UINT8_C(0xff)) { pThis->enmEncoding = RTINIFILEENCODING_UTF16BE; rc = RTUtf16BigCalcUtf8LenEx((PCRTUTF16)&pThis->pszFile[2], RTSTR_MAX, &cchUtf8); } else if ( (uint8_t)pThis->pszFile[0] == UINT8_C(0xff) && (uint8_t)pThis->pszFile[1] == UINT8_C(0xfe)) { pThis->enmEncoding = RTINIFILEENCODING_UTF16LE; rc = RTUtf16LittleCalcUtf8LenEx((PCRTUTF16)&pThis->pszFile[2], RTSTR_MAX, &cchUtf8); } else { pThis->enmEncoding = RTINIFILEENCODING_ANSI; rc = RTLatin1CalcUtf8LenEx(pThis->pszFile, RTSTR_MAX, &cchUtf8); } if (RT_FAILURE(rc)) return rc; char *pszUtf8Bom = (char *)RTMemAllocZ(3 + cchUtf8 + 1); if (!pszUtf8Bom) return VERR_NO_MEMORY; pszUtf8Bom[0] = '\xEF'; pszUtf8Bom[1] = '\xBB'; pszUtf8Bom[2] = '\xBF'; char *pszUtf8 = pszUtf8Bom + 3; if (pThis->enmEncoding == RTINIFILEENCODING_UTF16BE) rc = RTUtf16BigToUtf8Ex((PCRTUTF16)&pThis->pszFile[2], RTSTR_MAX, &pszUtf8, cchUtf8 + 1, NULL); else if (pThis->enmEncoding == RTINIFILEENCODING_UTF16LE) rc = RTUtf16LittleToUtf8Ex((PCRTUTF16)&pThis->pszFile[2], RTSTR_MAX, &pszUtf8, cchUtf8 + 1, NULL); else rc = RTLatin1ToUtf8Ex(pThis->pszFile, RTSTR_MAX, &pszUtf8, cchUtf8 + 1, NULL); AssertRCReturnStmt(rc, RTMemFree(pszUtf8Bom), rc); RTMemFree(pThis->pszFile); pThis->pszFile = pszUtf8Bom; pThis->cbFile = 3 + (uint32_t)cchUtf8; } /* * Do a rough section count. * Section zero is for unsectioned values at the start of the file. */ uint32_t cSections = 1; const char *psz = pThis->pszFile + 3; char ch; while ((ch = *psz) != '\0') { while (RT_C_IS_SPACE(ch)) ch = *++psz; if (ch == '[') cSections++; /* next line. */ psz = strchr(psz, '\n'); if (psz) psz++; else break; } if (cSections > RTINIFILE_MAX_SECTIONS) return VERR_TOO_MUCH_DATA; /* * Allocation section array and do the preparsing. */ pThis->paSections = (PRTINIFILESECTION)RTMemAllocZ(sizeof(pThis->paSections[0]) * cSections); if (!pThis->paSections) return VERR_NO_MEMORY; uint32_t iSection = 0; pThis->paSections[0].offName = 3; pThis->paSections[0].cchName = 0; pThis->paSections[0].cchSkipToValues = 0; psz = pThis->pszFile + 3; while ((ch = *psz) != '\0') { const char *const pszLine = psz; while (RT_C_IS_SPACE(ch)) ch = *++psz; if (ch == '[') { /* Complete previous section. */ pThis->paSections[iSection].cchSection = (uint32_t)(pszLine - &pThis->pszFile[pThis->paSections[iSection].offName]); /* New section. */ iSection++; AssertReturn(iSection < cSections, VERR_INTERNAL_ERROR_3); const char * const pszName = ++psz; pThis->paSections[iSection].offName = (uint32_t)(psz - pThis->pszFile); /* Figure the name length. We're very very relaxed about terminating bracket. */ while ((ch = *psz) != '\0' && ch != ']' && ch != '\r' && ch != '\n') psz++; pThis->paSections[iSection].cchName = (uint32_t)(psz - pszName); /* Set skip count to the start of the next line. */ while (ch != '\0' && ch != '\n') ch = *++psz; pThis->paSections[iSection].cchSkipToValues = (uint32_t)(psz - pszName + 1); if (ch == '\n') psz++; else break; } else { psz = strchr(psz, '\n'); if (psz) psz++; else break; } } /* Complete the final section. */ pThis->paSections[iSection].cchSection = pThis->cbFile - pThis->paSections[iSection].offName; pThis->cSections = iSection + 1; return VINF_SUCCESS; } RTDECL(int) RTIniFileCreateFromVfsFile(PRTINIFILE phIniFile, RTVFSFILE hVfsFile, uint32_t fFlags) { /* * Validate input, retaining a reference to the file. */ AssertPtrReturn(phIniFile, VERR_INVALID_POINTER); AssertReturn(!(fFlags & ~RTINIFILE_F_VALID_MASK), VERR_INVALID_FLAGS); uint32_t cRefs = RTVfsFileRetain(hVfsFile); AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE); /* * Create an instance. */ PRTINIFILEINT pThis = (PRTINIFILEINT)RTMemAllocZ(sizeof(*pThis)); if (pThis) { pThis->u32Magic = RTINIFILE_MAGIC; pThis->cRefs = 1; pThis->hVfsFile = hVfsFile; pThis->fFlags = fFlags; int rc = rtIniFileLoad(pThis); if (RT_SUCCESS(rc)) { *phIniFile = pThis; return VINF_SUCCESS; } RTIniFileRelease(pThis); return rc; } RTVfsFileRelease(hVfsFile); return VERR_NO_MEMORY; } RTDECL(uint32_t) RTIniFileRetain(RTINIFILE hIniFile) { PRTINIFILEINT pThis = hIniFile; AssertPtrReturn(pThis, UINT32_MAX); AssertReturn(pThis->u32Magic == RTINIFILE_MAGIC, UINT32_MAX); uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs); Assert(cRefs > 1); Assert(cRefs < _64K); return cRefs; } RTDECL(uint32_t) RTIniFileRelease(RTINIFILE hIniFile) { if (hIniFile == NIL_RTINIFILE) return 0; PRTINIFILEINT pThis = hIniFile; AssertPtrReturn(pThis, UINT32_MAX); AssertReturn(pThis->u32Magic == RTINIFILE_MAGIC, UINT32_MAX); uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs); Assert(cRefs < _64K); if (cRefs == 0) { AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, RTINIFILE_MAGIC_DEAD, RTINIFILE_MAGIC), UINT32_MAX); RTMemFree(pThis->paSections); pThis->paSections = NULL; RTMemFree(pThis->pszFile); pThis->pszFile = NULL; RTVfsFileRelease(pThis->hVfsFile); pThis->hVfsFile = NIL_RTVFSFILE; RTMemFree(pThis); } return cRefs; } /** * Worker for RTIniFileQueryValue. */ static int rtIniFileQueryValueInSection(PRTINIFILEINT pThis, PRTINIFILESECTION pSection, const char *pszKey, size_t cchKey, char *pszValue, size_t cbValue, size_t *pcbActual) { /* * Scan the section, looking for the matching key. */ Assert(pSection->cchSkipToValues <= pSection->cchSection); const char * const pszEnd = &pThis->pszFile[pSection->offName + pSection->cchSection]; const char * pszNext = pszEnd; for (const char *psz = &pThis->pszFile[pSection->offName + pSection->cchSkipToValues]; (uintptr_t)psz < (uintptr_t)pszEnd; psz = pszNext) { /* Find start of next line so we can use 'continue' to skip a line. */ pszNext = strchr(psz, '\n'); if (pszNext) pszNext++; else pszNext = pszEnd; /* Skip leading spaces. */ char ch; while ((ch = *psz) != '\0' && RT_C_IS_SPACE(ch)) psz++; if ( ch != ';' /* comment line */ && ch != '\n' /* empty line */ && ch != '\r' /* empty line */ && (uintptr_t)psz < (uintptr_t)pszEnd) { /* Find end of key name, if any. */ const char *pszCurKey = psz; size_t cchCurKey; const char *pszEqual; if (ch != '=') { /** @todo deal with escaped equal signs? */ pszEqual = strchr(psz, '='); if (pszEqual) { if ((uintptr_t)pszEqual < (uintptr_t)pszNext) cchCurKey = pszEqual - pszCurKey; else continue; } else break; /* Strip trailing spaces from the current key name. */ while (cchCurKey > 0 && RT_C_IS_SPACE(pszCurKey[cchCurKey - 1])) cchCurKey--; } else { cchCurKey = 0; pszEqual = psz; } /* Match the keys. */ /** @todo escape sequences? */ if ( cchCurKey == cchKey && RTStrNICmp(pszCurKey, pszKey, cchKey) == 0) { /* * Copy out the return value, without quotes. */ /* Skip leading blanks. */ psz = pszEqual + 1; while ((ch = *psz) && RT_C_IS_SPACE(ch) && ch != '\n') psz++; /* Strip trailing spaces. */ size_t cchCurValue = pszNext - psz; while (cchCurValue > 1 && RT_C_IS_SPACE(psz[cchCurValue - 1])) cchCurValue--; /* Strip quotes. */ if ( cchCurValue > 2 && ( (ch = *psz) == '"' || ch == '\'' ) && psz[cchCurValue - 1] == ch) { cchCurValue -= 2; psz++; } /* Do the copying. */ if (cchCurValue < cbValue) { memcpy(pszValue, psz, cchCurValue); pszValue[cchCurValue] = '\0'; if (pcbActual) *pcbActual = cchCurValue; return VINF_SUCCESS; } if (cbValue > 0) { memcpy(pszValue, psz, cbValue - 1); pszValue[cbValue - 1] = '\0'; } if (pcbActual) *pcbActual = cchCurValue + 1; return VERR_BUFFER_OVERFLOW; } } } return VERR_NOT_FOUND; } RTDECL(int) RTIniFileQueryValue(RTINIFILE hIniFile, const char *pszSection, const char *pszKey, char *pszValue, size_t cbValue, size_t *pcbActual) { /* * Validate input. */ PRTINIFILEINT pThis = hIniFile; AssertPtrReturn(pThis, VERR_INVALID_HANDLE); AssertReturn(pThis->u32Magic == RTINIFILE_MAGIC, VERR_INVALID_HANDLE); AssertPtrNullReturn(pszSection, VERR_INVALID_POINTER); AssertPtrReturn(pszKey, VERR_INVALID_POINTER); size_t const cchKey = strlen(pszKey); if (cbValue) AssertPtrReturn(pszValue, VERR_INVALID_POINTER); AssertPtrNullReturn(pcbActual, VERR_INVALID_POINTER); /* * Search relevant sections. */ int rc; if (pszSection == NULL) rc = rtIniFileQueryValueInSection(pThis, &pThis->paSections[0], pszKey, cchKey, pszValue, cbValue, pcbActual); else { rc = VERR_NOT_FOUND; uint32_t const cchSection = (uint32_t)strlen(pszSection); for (uint32_t iSection = 1; iSection < pThis->cSections; iSection++) if ( pThis->paSections[iSection].cchName == cchSection && RTStrNICmp(&pThis->pszFile[pThis->paSections[iSection].offName], pszSection, cchSection) == 0) { rc = rtIniFileQueryValueInSection(pThis, &pThis->paSections[iSection], pszKey, cchKey, pszValue, cbValue, pcbActual); if (rc != VERR_NOT_FOUND) break; } } return rc; } /** * Worker for RTIniFileQueryPair. * * This can also be used to count the number of pairs in a section. */ static int rtIniFileQueryPairInSection(PRTINIFILEINT pThis, PRTINIFILESECTION pSection, uint32_t *pidxPair, char *pszKey, size_t cbKey, size_t *pcbKeyActual, char *pszValue, size_t cbValue, size_t *pcbValueActual) { uint32_t idxPair = *pidxPair; /* * Scan the section, looking for the matching key. */ Assert(pSection->cchSkipToValues <= pSection->cchSection); const char * const pszEnd = &pThis->pszFile[pSection->offName + pSection->cchSection]; const char * pszNext = pszEnd; for (const char *psz = &pThis->pszFile[pSection->offName + pSection->cchSkipToValues]; (uintptr_t)psz < (uintptr_t)pszEnd; psz = pszNext) { /* Find start of next line so we can use 'continue' to skip a line. */ pszNext = strchr(psz, '\n'); if (pszNext) pszNext++; else pszNext = pszEnd; /* Skip leading spaces. */ char ch; while ((ch = *psz) != '\0' && RT_C_IS_SPACE(ch)) psz++; if ( ch != ';' /* comment line */ && ch != '\n' /* empty line */ && ch != '\r' /* empty line */ && (uintptr_t)psz < (uintptr_t)pszEnd) { /* Find end of key name, if any. */ const char *pszCurKey = psz; size_t cchCurKey; const char *pszEqual; if (ch != '=') { /** @todo deal with escaped equal signs? */ pszEqual = strchr(psz, '='); if (pszEqual) { if ((uintptr_t)pszEqual < (uintptr_t)pszNext) cchCurKey = pszEqual - pszCurKey; else continue; } else break; } else { cchCurKey = 0; pszEqual = psz; } /* Is this the pair we're looking for? */ if (idxPair > 0) idxPair--; else { /* * Yes it's the stuff we're looking for. * Prepare the the return stuff. */ /* Strip trailing spaces from the key name. */ while (cchCurKey > 0 && RT_C_IS_SPACE(pszCurKey[cchCurKey - 1])) cchCurKey--; /* Skip leading blanks from the value. */ psz = pszEqual + 1; while ((ch = *psz) && RT_C_IS_SPACE(ch) && ch != '\n') psz++; /* Strip trailing spaces from the value. */ size_t cchCurValue = pszNext - psz; while (cchCurValue > 1 && RT_C_IS_SPACE(psz[cchCurValue - 1])) cchCurValue--; /* Strip value quotes. */ if ( cchCurValue > 2 && ( (ch = *psz) == '"' || ch == '\'' ) && psz[cchCurValue - 1] == ch) { cchCurValue -= 2; psz++; } /* * Copy the stuff out. */ if ( cchCurValue < cbValue && cchCurKey < cbKey) { memcpy(pszKey, pszCurKey, cchCurKey); pszKey[cchCurKey] = '\0'; if (pcbKeyActual) *pcbKeyActual = cchCurKey; memcpy(pszValue, psz, cchCurValue); pszValue[cchCurValue] = '\0'; if (pcbValueActual) *pcbValueActual = cchCurValue; *pidxPair = 0; return VINF_SUCCESS; } /* Buffer overflow. Copy out what we can. */ if (cbKey > 0) { if (cchCurKey < cbKey) cbKey = cchCurKey + 1; memcpy(pszKey, pszCurKey, cbKey - 1); pszKey[cbKey - 1] = '\0'; } if (pcbKeyActual) *pcbKeyActual = cchCurKey + 1; if (cbValue > 0) { if (cchCurValue < cbValue) cbValue = cchCurValue + 1; memcpy(pszValue, psz, cbValue - 1); pszValue[cbValue - 1] = '\0'; } if (pcbValueActual) *pcbValueActual = cchCurValue + 1; *pidxPair = 0; return VERR_BUFFER_OVERFLOW; } } } *pidxPair = idxPair; return VERR_NOT_FOUND; } RTDECL(int) RTIniFileQueryPair(RTINIFILE hIniFile, const char *pszSection, uint32_t idxPair, char *pszKey, size_t cbKey, size_t *pcbKeyActual, char *pszValue, size_t cbValue, size_t *pcbValueActual) { /* * Validate input. */ PRTINIFILEINT pThis = hIniFile; AssertPtrReturn(pThis, VERR_INVALID_HANDLE); AssertReturn(pThis->u32Magic == RTINIFILE_MAGIC, VERR_INVALID_HANDLE); AssertPtrNullReturn(pszSection, VERR_INVALID_POINTER); if (cbKey) AssertPtrReturn(pszKey, VERR_INVALID_POINTER); AssertPtrNullReturn(pcbKeyActual, VERR_INVALID_POINTER); if (cbValue) AssertPtrReturn(pszValue, VERR_INVALID_POINTER); AssertPtrNullReturn(pcbValueActual, VERR_INVALID_POINTER); /* * Search relevant sections. */ int rc; if (pszSection == NULL) rc = rtIniFileQueryPairInSection(pThis, &pThis->paSections[0], &idxPair, pszKey, cbKey, pcbKeyActual, pszValue, cbValue, pcbValueActual); else { rc = VERR_NOT_FOUND; uint32_t const cchSection = (uint32_t)strlen(pszSection); for (uint32_t iSection = 1; iSection < pThis->cSections; iSection++) if ( pThis->paSections[iSection].cchName == cchSection && RTStrNICmp(&pThis->pszFile[pThis->paSections[iSection].offName], pszSection, cchSection) == 0) { rc = rtIniFileQueryPairInSection(pThis, &pThis->paSections[iSection], &idxPair, pszKey, cbKey, pcbKeyActual, pszValue, cbValue, pcbValueActual); if (rc != VERR_NOT_FOUND) break; } } return rc; }