Adding upstream version 7.0.6-dfsg.upstream/7.0.6-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 388 insertions, 0 deletions

diff --git a/src/VBox/Main/src-all/TextScript.cpp b/src/VBox/Main/src-all/TextScript.cpp
new file mode 100644
index 00000000..94811057
--- /dev/null
+++ b/src/VBox/Main/src-all/TextScript.cpp
@@ -0,0 +1,388 @@
+/* $Id: TextScript.cpp $ */
+/** @file
+ * Classes for reading/parsing/saving text scripts (unattended installation, ++).
+ */
+
+/*
+ * Copyright (C) 2006-2022 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 <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_MAIN_UNATTENDED
+#include "LoggingNew.h"
+#include "TextScript.h"
+
+#include <VBox/err.h>
+
+#include <iprt/ctype.h>
+#include <iprt/file.h>
+#include <iprt/vfs.h>
+#include <iprt/path.h>
+
+using namespace std;
+
+
+/*********************************************************************************************************************************
+*   BaseTextScript Implementation                                                                                                *
+*********************************************************************************************************************************/
+
+HRESULT BaseTextScript::read(const Utf8Str &rStrFilename)
+{
+    /*
+     * Open the file for reading and figure it's size.  Capping the size
+     * at 16MB so we don't exaust the heap on bad input.
+     */
+    HRESULT   hrc;
+    RTVFSFILE hVfsFile;
+    int vrc = RTVfsFileOpenNormal(rStrFilename.c_str(), RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE, &hVfsFile);
+    if (RT_SUCCESS(vrc))
+    {
+        hrc = readFromHandle(hVfsFile, rStrFilename.c_str());
+        RTVfsFileRelease(hVfsFile);
+    }
+    else
+        hrc = mpSetError->setErrorVrc(vrc, tr("Failed to open '%s' (%Rrc)"), rStrFilename.c_str(), vrc);
+    return hrc;
+}
+
+HRESULT BaseTextScript::readFromHandle(RTVFSFILE hVfsFile, const char *pszFilename)
+{
+    /*
+     * Open the file for reading and figure it's size.  Capping the size
+     * at 16MB so we don't exaust the heap on bad input.
+     */
+    HRESULT  hrc;
+    uint64_t cbFile = 0;
+    int vrc = RTVfsFileQuerySize(hVfsFile, &cbFile);
+    if (   RT_SUCCESS(vrc)
+        && cbFile < _16M)
+    {
+        /*
+         * Exploint the jolt() feature of RTCString and read the content directly into
+         * its storage buffer.
+         */
+        vrc = mStrScriptFullContent.reserveNoThrow((size_t)cbFile + 1);
+        if (RT_SUCCESS(vrc))
+        {
+            char *pszDst = mStrScriptFullContent.mutableRaw();
+            vrc = RTVfsFileReadAt(hVfsFile, 0 /*off*/, pszDst, (size_t)cbFile, NULL);
+            pszDst[(size_t)cbFile] = '\0';
+            if (RT_SUCCESS(vrc))
+            {
+                /*
+                 * We must validate the encoding or we'll be subject to potential security trouble.
+                 * If this turns out to be problematic, we will need to implement codeset
+                 * conversion coping mechanisms.
+                 */
+                vrc = RTStrValidateEncodingEx(pszDst, (size_t)cbFile + 1,
+                                              RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED | RTSTR_VALIDATE_ENCODING_EXACT_LENGTH);
+                if (RT_SUCCESS(vrc))
+                {
+                    mStrScriptFullContent.jolt();
+                    return S_OK;
+                }
+
+                hrc = mpSetError->setErrorVrc(vrc, tr("'%s' isn't valid UTF-8: %Rrc"), pszFilename, vrc);
+            }
+            else
+                hrc = mpSetError->setErrorVrc(vrc, tr("Error reading '%s': %Rrc"), pszFilename, vrc);
+            mStrScriptFullContent.setNull();
+        }
+        else
+            hrc = mpSetError->setErrorVrc(vrc, tr("Failed to allocate memory (%'RU64 bytes) for '%s'", "", cbFile),
+                                          cbFile, pszFilename);
+    }
+    else if (RT_SUCCESS(vrc))
+        hrc = mpSetError->setErrorVrc(VERR_FILE_TOO_BIG, tr("'%s' is too big (max 16MB): %'RU64"), pszFilename, cbFile);
+    else
+        hrc = mpSetError->setErrorVrc(vrc, tr("RTVfsFileQuerySize failed (%Rrc)"), vrc);
+    return hrc;
+}
+
+HRESULT BaseTextScript::save(const Utf8Str &rStrFilename, bool fOverwrite)
+{
+    /*
+     * We may have to append the default filename to the
+     */
+    const char *pszFilename = rStrFilename.c_str();
+    Utf8Str     strWithDefaultFilename;
+    if (   getDefaultFilename() != NULL
+        && *getDefaultFilename() != '\0'
+        && RTDirExists(rStrFilename.c_str()) )
+    {
+        try
+        {
+            strWithDefaultFilename = rStrFilename;
+            strWithDefaultFilename.append(RTPATH_SLASH);
+            strWithDefaultFilename.append(getDefaultFilename());
+        }
+        catch (std::bad_alloc &)
+        {
+            return E_OUTOFMEMORY;
+        }
+        pszFilename = strWithDefaultFilename.c_str();
+    }
+
+    /*
+     * Save the filename for later use.
+     */
+    try
+    {
+        mStrSavedPath = pszFilename;
+    }
+    catch (std::bad_alloc &)
+    {
+        return E_OUTOFMEMORY;
+    }
+
+    /*
+     * Use the saveToString method to produce the content.
+     */
+    Utf8Str strDst;
+    HRESULT hrc = saveToString(strDst);
+    if (SUCCEEDED(hrc))
+    {
+        /*
+         * Write the content.
+         */
+        RTFILE   hFile;
+        uint64_t fOpen = RTFILE_O_WRITE | RTFILE_O_DENY_ALL;
+        if (fOverwrite)
+            fOpen |= RTFILE_O_CREATE_REPLACE;
+        else
+            fOpen |= RTFILE_O_CREATE;
+        int vrc = RTFileOpen(&hFile, pszFilename, fOpen);
+        if (RT_SUCCESS(vrc))
+        {
+            vrc = RTFileWrite(hFile, strDst.c_str(), strDst.length(), NULL);
+            if (RT_SUCCESS(vrc))
+            {
+                vrc = RTFileClose(hFile);
+                if (RT_SUCCESS(vrc))
+                {
+                    LogRelFlow(("GeneralTextScript::save(): saved %zu bytes to '%s'\n", strDst.length(), pszFilename));
+                    return S_OK;
+                }
+            }
+            RTFileClose(hFile);
+            RTFileDelete(pszFilename);
+            hrc = mpSetError->setErrorVrc(vrc, tr("Error writing to '%s' (%Rrc)"), pszFilename, vrc);
+        }
+        else
+            hrc = mpSetError->setErrorVrc(vrc, tr("Error creating/replacing '%s' (%Rrc)"), pszFilename, vrc);
+    }
+    return hrc;
+}
+
+
+
+/*********************************************************************************************************************************
+*   GeneralTextScript Implementation                                                                                             *
+*********************************************************************************************************************************/
+
+HRESULT GeneralTextScript::parse()
+{
+    AssertReturn(!mfDataParsed, mpSetError->setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("parse called more than once")));
+
+    /*
+     * Split the raw context into an array of lines.
+     */
+    try
+    {
+        mScriptContentByLines = mStrScriptFullContent.split("\n");
+    }
+    catch (std::bad_alloc &)
+    {
+        mScriptContentByLines.clear();
+        return E_OUTOFMEMORY;
+    }
+
+    mfDataParsed = true;
+    return S_OK;
+}
+
+HRESULT GeneralTextScript::saveToString(Utf8Str &rStrDst)
+{
+    AssertReturn(mfDataParsed, mpSetError->setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("saveToString() called before parse()")));
+
+    /*
+     * Calc the required size first.
+     */
+    size_t const cLines = mScriptContentByLines.size();
+    size_t       cbTotal = 1;
+    for (size_t iLine = 0; iLine < cLines; iLine++)
+        cbTotal = mScriptContentByLines[iLine].length() + 1;
+
+    /*
+     * Clear the output and try reserve sufficient space.
+     */
+    rStrDst.setNull();
+
+    int vrc = rStrDst.reserveNoThrow(cbTotal);
+    if (RT_FAILURE(vrc))
+        return E_OUTOFMEMORY;
+
+    /*
+     * Assemble the output.
+     */
+    for (size_t iLine = 0; iLine < cLines; iLine++)
+    {
+        try
+        {
+            rStrDst.append(mScriptContentByLines[iLine]);
+            rStrDst.append('\n');
+        }
+        catch (std::bad_alloc &)
+        {
+            return E_OUTOFMEMORY;
+        }
+    }
+
+    return S_OK;
+}
+
+const RTCString &GeneralTextScript::getContentOfLine(size_t idxLine)
+{
+    if (idxLine < mScriptContentByLines.size())
+        return mScriptContentByLines[idxLine];
+    return Utf8Str::Empty;
+}
+
+
+HRESULT GeneralTextScript::setContentOfLine(size_t idxLine, const Utf8Str &rStrNewLine)
+{
+    AssertReturn(idxLine < mScriptContentByLines.size(),
+                 mpSetError->setErrorBoth(E_FAIL, VERR_OUT_OF_RANGE,
+                                          tr("attempting to set line %zu when there are only %zu lines", "",
+                                             mScriptContentByLines.size()),
+                                          idxLine, mScriptContentByLines.size()));
+    try
+    {
+        mScriptContentByLines[idxLine] = rStrNewLine;
+    }
+    catch (std::bad_alloc &)
+    {
+        return E_OUTOFMEMORY;
+    }
+    return S_OK;
+}
+
+vector<size_t> GeneralTextScript::findTemplate(const Utf8Str &rStrNeedle,
+                                               RTCString::CaseSensitivity enmCase /*= RTCString::CaseSensitive*/)
+{
+    vector<size_t> vecHitLineNumbers;
+    size_t const   cLines = mScriptContentByLines.size();
+    for (size_t iLine = 0; iLine < cLines; iLine++)
+        if (mScriptContentByLines[iLine].contains(rStrNeedle, enmCase))
+            vecHitLineNumbers.push_back(iLine);
+
+    return vecHitLineNumbers;
+}
+
+HRESULT GeneralTextScript::findAndReplace(size_t idxLine, const Utf8Str &rStrNeedle, const Utf8Str &rStrReplacement)
+{
+    AssertReturn(idxLine < mScriptContentByLines.size(),
+                 mpSetError->setErrorBoth(E_FAIL, VERR_OUT_OF_RANGE,
+                                          tr("attempting search&replace in line %zu when there are only %zu lines", "",
+                                             mScriptContentByLines.size()),
+                                          idxLine, mScriptContentByLines.size()));
+
+    RTCString &rDstString = mScriptContentByLines[idxLine];
+    size_t const offNeedle = rDstString.find(&rStrNeedle);
+    if (offNeedle != RTCString::npos)
+    {
+        try
+        {
+            RTCString strBefore(rDstString, 0, offNeedle);
+            RTCString strAfter(rDstString, offNeedle + rStrNeedle.length());
+            rDstString = strBefore;
+            strBefore.setNull();
+            rDstString.append(rStrReplacement);
+            rDstString.append(strAfter);
+        }
+        catch (std::bad_alloc &)
+        {
+            return E_OUTOFMEMORY;
+        }
+    }
+    return S_OK;
+}
+
+HRESULT GeneralTextScript::appendToLine(size_t idxLine, const Utf8Str &rStrToAppend)
+{
+    AssertReturn(idxLine < mScriptContentByLines.size(),
+                 mpSetError->setErrorBoth(E_FAIL, VERR_OUT_OF_RANGE,
+                                          tr("appending to line %zu when there are only %zu lines", "",
+                                             mScriptContentByLines.size()),
+                                          idxLine, mScriptContentByLines.size()));
+
+    try
+    {
+        mScriptContentByLines[idxLine].append(rStrToAppend);
+    }
+    catch (std::bad_alloc &)
+    {
+        return E_OUTOFMEMORY;
+    }
+    return S_OK;
+}
+
+HRESULT GeneralTextScript::prependToLine(size_t idxLine, const Utf8Str &rStrToPrepend)
+{
+    AssertReturn(idxLine < mScriptContentByLines.size(),
+                 mpSetError->setErrorBoth(E_FAIL, VERR_OUT_OF_RANGE,
+                                          tr("prepending to line %zu when there are only %zu lines", "",
+                                             mScriptContentByLines.size()),
+                                          idxLine, mScriptContentByLines.size()));
+
+    RTCString &rDstString = mScriptContentByLines[idxLine];
+    try
+    {
+        RTCString strCopy;
+        rDstString.swap(strCopy);
+        rDstString.reserve(strCopy.length() + rStrToPrepend.length() + 1);
+        rDstString = rStrToPrepend;
+        rDstString.append(strCopy);
+    }
+    catch (std::bad_alloc &)
+    {
+        return E_OUTOFMEMORY;
+    }
+    return S_OK;
+}
+
+HRESULT GeneralTextScript::appendLine(const Utf8Str &rStrLineToAppend)
+{
+    AssertReturn(mfDataParsed, mpSetError->setErrorBoth(E_FAIL, VERR_WRONG_ORDER, tr("appendLine() called before parse()")));
+
+    try
+    {
+        mScriptContentByLines.append(rStrLineToAppend);
+    }
+    catch (std::bad_alloc &)
+    {
+        return E_OUTOFMEMORY;
+    }
+    return S_OK;
+}