From 8987652fe1f1dca674a0726e6d967c60ed79e8b6 Mon Sep 17 00:00:00 2001

From: Matthew Almond <malmond@fb.com>

Date: Mon, 8 Mar 2021 12:57:53 -0800

Subject: [PATCH 1/2] Expose librepo's checksum functions via SWIG

DNF has been carrying around yum's old checksum function. These

functions duplicate code in librepo. They are slower because librepo can

employ caching of digests. Lastly, these functions in Python do not know

about changes in checksum logic like

https://github.com/rpm-software-management/librepo/pull/222

The choices here are:

1. Replicate `lr_checksum_cow_fd()` and caching logic in Python

2. Just use librepo from dnf.

This is 2. Note there was bug in librepo that forces no caching

for `checksum_value()`

(https://github.com/rpm-software-management/librepo/issues/233). This is

now fixed, so we depend on librepo-1.13.1 to ensure this fix is present.

This change goes hand in hand with a change to `dnf` itself to make use

of the new functions and eliminate the old ones. This is

https://github.com/rpm-software-management/dnf/pull/1743. We bump the

version of this library in the next commit to ensure this dependency is

expressed properly.

On errors, these functions raise libdnf.error.Error which can be easily

mapped into MiscError in dnf

---

 bindings/swig/utils.i  |  3 +++

 libdnf/utils/utils.cpp | 50 ++++++++++++++++++++++++++++++++++++++++++

 libdnf/utils/utils.hpp | 16 ++++++++++++++

 3 files changed, 69 insertions(+)

diff --git a/bindings/swig/utils.i b/bindings/swig/utils.i

index 60fabb02d..df323e375 100644

--- a/bindings/swig/utils.i

+++ b/bindings/swig/utils.i

@@ -44,4 +44,7 @@ namespace libdnf { namespace filesystem {

 void decompress(const char * inPath, const char * outPath, mode_t outMode, const char * compressType = nullptr);

+bool checksum_check(const char * type, const char * inPath, const char * checksum_valid);

+std::string checksum_value(const char * type, const char * inPath);

+

 }}

diff --git a/libdnf/utils/utils.cpp b/libdnf/utils/utils.cpp

index 1a83bfbd2..450718d37 100644

--- a/libdnf/utils/utils.cpp

+++ b/libdnf/utils/utils.cpp

@@ -1,6 +1,7 @@

 #include "utils.hpp"

 #include "libdnf/dnf-sack-private.hpp"

 #include "libdnf/sack/advisorymodule.hpp"

+#include <librepo/librepo.h>

 #include <tinyformat/tinyformat.hpp>

@@ -300,6 +301,55 @@ void decompress(const char * inPath, const char * outPath, mode_t outMode, const

     fclose(inFile);

 }

+void checksum(const char * type, const char * inPath, const char * checksum_valid, bool * valid_out, gchar ** calculated_out)

+{

+    GError * errP{nullptr};

+    gboolean valid;

+    LrChecksumType lr_type = lr_checksum_type(type);

+

+    if (lr_type == LR_CHECKSUM_UNKNOWN)

+        throw libdnf::Error(tfm::format("Unknown checksum type %s", type));

+

+    auto inFd = open(inPath, O_RDONLY);

+

+    if (inFd == -1)

+        throw libdnf::Error(tfm::format("Error opening %s: %s", inPath, strerror(errno)));

+

+    auto ret = lr_checksum_fd_compare(lr_type,

+                      inFd,

+                      /**

+                       * If checksum_valid references a string, pass it in, else use

+                       * an empty string

+                       */

+                      checksum_valid ? checksum_valid : "",

+                      TRUE,

+                      &valid,

+                      calculated_out,

+                      &errP);

+

+    close(inFd);

+    if (!ret)

+      throw libdnf::Error(tfm::format("Error calculating checksum %s: (%d, %s)", inPath, errP->code, errP->message));

+    if (valid_out)

+        *valid_out = valid == TRUE; /* gboolean -> bool */

+}

+

+

+bool checksum_check(const char * type, const char * inPath, const char * checksum_valid)

+{

+    bool valid;

+    checksum(type, inPath, checksum_valid, &valid, NULL);

+    return valid;

+}

+

+std::string checksum_value(const char * type, const char * inPath)

+{

+    g_autofree gchar *calculated = NULL;

+    checksum(type, inPath, NULL, NULL, &calculated);

+    std::string out(calculated);

+    return out;

+}

+

 }

 namespace numeric {

diff --git a/libdnf/utils/utils.hpp b/libdnf/utils/utils.hpp

index 5d755e017..43ca9ff34 100644

--- a/libdnf/utils/utils.hpp

+++ b/libdnf/utils/utils.hpp

@@ -68,6 +68,22 @@ std::vector<std::string> getDirContent(const std::string &dirPath);

 * @param compressType Type of compression (".bz2", ".gz", ...), nullptr - detect from inPath filename. Defaults to nullptr.

 */

 void decompress(const char * inPath, const char * outPath, mode_t outMode, const char * compressType = nullptr);

+

+/**

+* @brief checksum file and return if matching.

+*

+* @param type Checksum type ("sha", "sha1", "sha256" etc). Raises libdnf::Error if invalid.

+* @param inPath Path to input file

+* @param valid_checksum hexadecimal encoded checksum string.

+*/

+bool checksum_check(const char * type, const char * inPath, const char * valid_checksum);

+/**

+* @brief checksum file and return checksum.

+*

+* @param type Checksum type ("sha", "sha1", "sha256" etc). Raises libdnf::Error if invalid.

+* @param inPath Path to input file

+*/

+std::string checksum_value(const char * type, const char * inPath);

 }

 namespace numeric {