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

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

1 files changed, 324 insertions, 0 deletions

diff --git a/include/VBox/GuestHost/DragAndDrop.h b/include/VBox/GuestHost/DragAndDrop.h
new file mode 100644
index 00000000..329c697e
--- /dev/null
+++ b/include/VBox/GuestHost/DragAndDrop.h
@@ -0,0 +1,324 @@
+/* $Id: DragAndDrop.h $ */
+/** @file
+ * DnD - Shared functions between host and guest.
+ */
+
+/*
+ * Copyright (C) 2014-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE 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.
+ */
+
+#ifndef VBOX_INCLUDED_GuestHost_DragAndDrop_h
+#define VBOX_INCLUDED_GuestHost_DragAndDrop_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/assert.h>
+#include <iprt/fs.h>
+
+#include <iprt/cpp/list.h>
+#include <iprt/cpp/ministring.h>
+
+/** DnDURIDroppedFiles flags. */
+typedef uint32_t DNDURIDROPPEDFILEFLAGS;
+
+/** No flags specified. */
+#define DNDURIDROPPEDFILE_FLAGS_NONE                   0
+
+/**
+ * Class for maintaining a "dropped files" directory
+ * on the host or guest. This will contain all received files & directories
+ * for a single drag and drop operation.
+ *
+ * In case of a failed drag and drop operation this class can also
+ * perform a gentle rollback if required.
+ */
+class DnDDroppedFiles
+{
+
+public:
+
+    DnDDroppedFiles(void);
+    DnDDroppedFiles(const char *pszPath, DNDURIDROPPEDFILEFLAGS fFlags = DNDURIDROPPEDFILE_FLAGS_NONE);
+    virtual ~DnDDroppedFiles(void);
+
+public:
+
+    int AddFile(const char *pszFile);
+    int AddDir(const char *pszDir);
+    int Close(void);
+    bool IsOpen(void) const;
+    int OpenEx(const char *pszPath, DNDURIDROPPEDFILEFLAGS fFlags = DNDURIDROPPEDFILE_FLAGS_NONE);
+    int OpenTemp(DNDURIDROPPEDFILEFLAGS fFlags = DNDURIDROPPEDFILE_FLAGS_NONE);
+    const char *GetDirAbs(void) const;
+    int Reopen(void);
+    int Reset(bool fDeleteContent);
+    int Rollback(void);
+
+protected:
+
+    int closeInternal(void);
+
+protected:
+
+    /** Open flags. */
+    uint32_t                     m_fOpen;
+    /** Directory handle for drop directory. */
+    RTDIR                        m_hDir;
+    /** Absolute path to drop directory. */
+    RTCString                    m_strPathAbs;
+    /** List for holding created directories in the case of a rollback. */
+    RTCList<RTCString>           m_lstDirs;
+    /** List for holding created files in the case of a rollback. */
+    RTCList<RTCString>           m_lstFiles;
+};
+
+bool DnDMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax);
+bool DnDMIMENeedsDropDir(const char *pcszFormat, size_t cchFormatMax);
+
+int DnDPathSanitizeFilename(char *pszPath, size_t cbPath);
+int DnDPathSanitize(char *pszPath, size_t cbPath);
+
+/** DnDURIObject flags. */
+typedef uint32_t DNDURIOBJECTFLAGS;
+
+/** No flags specified. */
+#define DNDURIOBJECT_FLAGS_NONE                   0
+
+/** Mask of all valid DnD URI object flags. */
+#define DNDURIOBJECT_FLAGS_VALID_MASK             UINT32_C(0x0)
+
+/**
+ * Class for handling DnD URI objects.
+ * This class abstracts the access and handling objects when performing DnD actions.
+ */
+class DnDURIObject
+{
+public:
+
+    /**
+     * Enumeration for specifying an URI object type.
+     */
+    enum Type
+    {
+        /** Unknown type, do not use. */
+        Type_Unknown = 0,
+        /** Object is a file. */
+        Type_File,
+        /** Object is a directory. */
+        Type_Directory,
+        /** The usual 32-bit hack. */
+        Type_32Bit_Hack = 0x7fffffff
+    };
+
+    /**
+     * Enumeration for specifying an URI object view
+     * for representing its data accordingly.
+     */
+    enum View
+    {
+        /** Unknown view, do not use. */
+        View_Unknown = 0,
+        /** Handle data from the source point of view. */
+        View_Source,
+        /** Handle data from the destination point of view. */
+        View_Target,
+        /** The usual 32-bit hack. */
+        View_Dest_32Bit_Hack = 0x7fffffff
+    };
+
+    DnDURIObject(void);
+    DnDURIObject(Type type,
+                 const RTCString &strSrcPathAbs = "",
+                 const RTCString &strDstPathAbs = "");
+    virtual ~DnDURIObject(void);
+
+public:
+
+    /**
+     * Returns the given absolute source path of the object.
+     *
+     * @return  Absolute source path of the object.
+     */
+    const RTCString &GetSourcePathAbs(void) const { return m_strSrcPathAbs; }
+
+    /**
+     * Returns the given, absolute destination path of the object.
+     *
+     * @return  Absolute destination path of the object.
+     */
+    const RTCString &GetDestPathAbs(void) const { return m_strTgtPathAbs; }
+
+    RTFMODE GetMode(void) const;
+
+    uint64_t GetProcessed(void) const;
+
+    uint64_t GetSize(void) const;
+
+    /**
+     * Returns the object's type.
+     *
+     * @return  The object's type.
+     */
+    Type GetType(void) const { return m_enmType; }
+
+    /**
+     * Returns the object's view.
+     *
+     * @return  The object's view.
+     */
+    View GetView(void) const { return m_enmView; }
+
+public:
+
+    int SetSize(uint64_t cbSize);
+
+public:
+
+    void Close(void);
+    bool IsComplete(void) const;
+    bool IsOpen(void) const;
+    int Open(View enmView, uint64_t fOpen, RTFMODE fMode = 0);
+    int OpenEx(const RTCString &strPath, View enmView, uint64_t fOpen = 0, RTFMODE fMode = 0, DNDURIOBJECTFLAGS = DNDURIOBJECT_FLAGS_NONE);
+    int QueryInfo(View enmView);
+    int Read(void *pvBuf, size_t cbBuf, uint32_t *pcbRead);
+    void Reset(void);
+    int Write(const void *pvBuf, size_t cbBuf, uint32_t *pcbWritten);
+
+public:
+
+    static int RebaseURIPath(RTCString &strPath, const RTCString &strBaseOld = "", const RTCString &strBaseNew = "");
+
+protected:
+
+    void closeInternal(void);
+    int queryInfoInternal(View enmView);
+
+protected:
+
+    /** The object's type. */
+    Type      m_enmType;
+    /** The object's view. */
+    View      m_enmView;
+    /** Absolute path (base) for the source. */
+    RTCString m_strSrcPathAbs;
+    /** Absolute path (base) for the target. */
+    RTCString m_strTgtPathAbs;
+    /** Whether the object is in "opened" state. */
+    bool      m_fIsOpen;
+
+    /** Union containing data depending on the object's type. */
+    union
+    {
+        /** Structure containing members for objects that
+         *  are files. */
+        struct
+        {
+            /** File handle. */
+            RTFILE      hFile;
+            /** File system object information of this file. */
+            RTFSOBJINFO objInfo;
+            /** Bytes to proces for reading/writing. */
+            uint64_t    cbToProcess;
+            /** Bytes processed reading/writing. */
+            uint64_t    cbProcessed;
+        } File;
+        struct
+        {
+            /** Directory handle. */
+            RTDIR       hDir;
+            /** File system object information of this directory. */
+            RTFSOBJINFO objInfo;
+        } Dir;
+    } u;
+};
+
+/** DnDURIList flags. */
+typedef uint32_t DNDURILISTFLAGS;
+
+/** No flags specified. */
+#define DNDURILIST_FLAGS_NONE                   0
+/** Keep the original paths, don't convert paths to relative ones. */
+#define DNDURILIST_FLAGS_ABSOLUTE_PATHS         RT_BIT(0)
+/** Resolve all symlinks. */
+#define DNDURILIST_FLAGS_RESOLVE_SYMLINKS       RT_BIT(1)
+/** Keep the files + directory entries open while
+ *  being in this list. */
+#define DNDURILIST_FLAGS_KEEP_OPEN              RT_BIT(2)
+/** Lazy loading: Only enumerate sub directories when needed.
+ ** @todo Implement lazy loading.  */
+#define DNDURILIST_FLAGS_LAZY                   RT_BIT(3)
+
+/** Mask of all valid DnD URI list flags. */
+#define DNDURILIST_FLAGS_VALID_MASK             UINT32_C(0xF)
+
+class DnDURIList
+{
+public:
+
+    DnDURIList(void);
+    virtual ~DnDURIList(void);
+
+public:
+
+    int AppendNativePath(const char *pszPath, DNDURILISTFLAGS fFlags);
+    int AppendNativePathsFromList(const char *pszNativePaths, size_t cbNativePaths, DNDURILISTFLAGS fFlags);
+    int AppendNativePathsFromList(const RTCList<RTCString> &lstNativePaths, DNDURILISTFLAGS fFlags);
+    int AppendURIPath(const char *pszURI, DNDURILISTFLAGS fFlags);
+    int AppendURIPathsFromList(const char *pszURIPaths, size_t cbURIPaths, DNDURILISTFLAGS fFlags);
+    int AppendURIPathsFromList(const RTCList<RTCString> &lstURI, DNDURILISTFLAGS fFlags);
+
+    void Clear(void);
+    DnDURIObject *First(void) { return m_lstTree.first(); }
+    bool IsEmpty(void) const { return m_lstTree.isEmpty(); }
+    void RemoveFirst(void);
+    int SetFromURIData(const void *pvData, size_t cbData, DNDURILISTFLAGS fFlags);
+
+    RTCString GetRootEntries(const RTCString &strPathBase = "", const RTCString &strSeparator = "\r\n") const;
+    uint64_t GetRootCount(void) const { return m_lstRoot.size(); }
+    uint64_t GetTotalCount(void) const { return m_cTotal; }
+    uint64_t GetTotalBytes(void) const { return m_cbTotal; }
+
+protected:
+
+    int addEntry(const char *pcszSource, const char *pcszTarget, DNDURILISTFLAGS fFlags);
+    int appendPathRecursive(const char *pcszSrcPath, const char *pcszDstPath, const char *pcszDstBase, size_t cchDstBase, DNDURILISTFLAGS fFlags);
+
+protected:
+
+    /** List of all top-level file/directory entries.
+     *  Note: All paths are kept internally as UNIX paths for
+     *        easier conversion/handling!  */
+    RTCList<RTCString>      m_lstRoot;
+    /** List of all URI objects added. The list's content
+     *  might vary depending on how the objects are being
+     *  added (lazy or not). */
+    RTCList<DnDURIObject *> m_lstTree;
+    /** Total number of all URI objects. */
+    uint64_t                m_cTotal;
+    /** Total size of all URI objects, that is, the file
+     *  size of all objects (in bytes).
+     *  Note: Do *not* size_t here, as we also want to support large files
+     *        on 32-bit guests. */
+    uint64_t                m_cbTotal;
+};
+
+#endif /* !VBOX_INCLUDED_GuestHost_DragAndDrop_h */
+