From d66dfc2815153b315f5b3fd9d3f93be670def26a Mon Sep 17 00:00:00 2001

From: Jaroslav Rohel <jrohel@redhat.com>

Date: Tue, 3 Sep 2019 12:55:51 +0200

Subject: [PATCH 09/10] Added dnf_move_recursive()

Moves a directory and its contents. If native move operations are

supported then this is used, otherwise a copy + delete fallback is used.

---

 libdnf/hy-iutil-private.hpp |  1 +

 libdnf/hy-iutil.cpp         | 95 +++++++++++++++++++++++++++++++++++--

 2 files changed, 93 insertions(+), 3 deletions(-)

diff --git a/libdnf/hy-iutil-private.hpp b/libdnf/hy-iutil-private.hpp

index 8b2b06d5..4920ad39 100644

--- a/libdnf/hy-iutil-private.hpp

+++ b/libdnf/hy-iutil-private.hpp

@@ -41,6 +41,7 @@ char *abspath(const char *path);

 int is_readable_rpm(const char *fn);

 int mkcachedir(char *path);

 gboolean mv(const char *old_path, const char *new_path, GError **error);

+gboolean dnf_move_recursive(const gchar *src_dir, const gchar *dst_dir, GError **error);

 char *this_username(void);

 /* misc utils */

diff --git a/libdnf/hy-iutil.cpp b/libdnf/hy-iutil.cpp

index 2c5af481..d3b57c79 100644

--- a/libdnf/hy-iutil.cpp

+++ b/libdnf/hy-iutil.cpp

@@ -20,12 +20,14 @@

 #include <assert.h>

 #include <errno.h>

+#include <dirent.h>

 #include <fcntl.h>

 #include <linux/limits.h>

 #include <pwd.h>

 #include <unistd.h>

 #include <stdio.h>

 #include <stdlib.h>

+#include <string.h>

 #include <sys/stat.h>

 #include <sys/types.h>

 #include <sys/utsname.h>

@@ -41,9 +43,6 @@ extern "C" {

 #include <solv/pool_parserpmrichdep.h>

 }

-// glib

-#include <glib.h>

-

 // hawkey

 #include "dnf-advisory-private.hpp"

 #include "dnf-types.h"

@@ -58,6 +57,12 @@ extern "C" {

 #include "utils/bgettext/bgettext-lib.h"

 #include "sack/packageset.hpp"

+// glib

+#include <glib.h>

+#include <gio/gio.h>

+

+#include <string>

+

 #define BUF_BLOCK 4096

 #define CHKSUM_TYPE REPOKEY_TYPE_SHA256

 #define CHKSUM_IDENT "H000"

@@ -328,6 +333,90 @@ mv(const char* old_path, const char* new_path, GError** error)

     return TRUE;

 }

+static gboolean

+copyFile(const std::string & srcPath, const std::string & dstPath, GError ** error)

+{

+    g_autoptr(GFile) src = g_file_new_for_path(srcPath.c_str());

+    g_autoptr(GFile) dest = g_file_new_for_path(dstPath.c_str());

+    return g_file_copy(src, dest,

+        static_cast<GFileCopyFlags>(G_FILE_COPY_NOFOLLOW_SYMLINKS | G_FILE_COPY_ALL_METADATA)

+        , NULL, NULL, NULL, error);

+}

+

+static gboolean

+copyRecursive(const std::string & srcPath, const std::string & dstPath, GError ** error)

+{

+    struct stat info;

+    if (!stat(srcPath.c_str(), &info)) {

+        if (S_ISDIR(info.st_mode)) {

+            if (mkdir(dstPath.c_str(), info.st_mode) == -1) {

+                auto err = errno;

+                g_set_error(error,

+                    DNF_ERROR,

+                    DNF_ERROR_INTERNAL_ERROR,

+                    _("cannot create directory %1$s: %2$s"),

+                    dstPath.c_str(), strerror(err));

+                return FALSE;

+            }

+            if (auto fd = opendir(srcPath.c_str())) {

+                int ret = TRUE;

+                while (auto dent = readdir(fd)) {

+                    auto name = dent->d_name;

+                    if (name[0] == '.' && (name[1] == '\0' || (name[1] == '.' && name[2] == '\0')))

+                        continue;

+                    std::string srcItem = srcPath + "/" + name;

+                    std::string dstItem = dstPath + "/" + name;

+                    ret = copyRecursive(srcItem, dstItem, error);

+                    if (!ret)

+                        break;

+                }

+                closedir(fd);

+                return ret;

+            } else {

+                auto err = errno;

+                g_set_error(error,

+                    DNF_ERROR,

+                    DNF_ERROR_INTERNAL_ERROR,

+                    _("cannot open directory %1$s: %2$s"),

+                    srcPath.c_str(), strerror(err));

+                return FALSE;

+            }

+        } else {

+            return copyFile(srcPath, dstPath, error);

+        }

+    } else {

+        auto err = errno;

+        g_set_error(error,

+            DNF_ERROR,

+            DNF_ERROR_INTERNAL_ERROR,

+            _("cannot stat path %1$s: %2$s"),

+            srcPath.c_str(), strerror(err));

+        return FALSE;

+    }

+}

+

+/**

+ * dnf_move_recursive:

+ * @src_dir: A source directory path

+ * @dst_dir: A destination directory path

+ * @error: A #GError, or %NULL

+ *

+ * Moves a directory and its contents. Native move is preferred,

+ * if not supported copy and delete fallback is used.

+ *

+ * Returns: %TRUE on successful move, %FALSE otherwise

+ **/

+gboolean

+dnf_move_recursive(const char * srcDir, const char * dstDir, GError ** error)

+{

+    if (rename(srcDir, dstDir) == -1) {

+        if (!copyRecursive(srcDir, dstDir, error))

+            return FALSE;

+        return dnf_remove_recursive(srcDir, error);

+    }

+    return TRUE;

+}

+

 char *

 this_username(void)

 {

-- 

2.21.0