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
rpm-software-management/librepo#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 is an open bug in librepo that forces no caching
for `checksum_value()`
(rpm-software-management/librepo#233). For
now we can keep the perf hit - this is no worse than the existing code
and aim for more correctness.

This change goes hand in hand with a change to `dnf` itself to make use
of the new functions and eliminate the old ones.

On errors, these functions raise libdnf.error.Error which can be easily
mapped into MiscError in dnf

Author: malmond77

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);
+
 }}

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>
 
@@ -311,6 +312,74 @@ void decompress(const char * inPath, const char * outPath, mode_t outMode, const
     fclose(inFile);
 }
 
+bool checksum_check(const char * type, const char * inPath, const char * checksum_valid)
+{
+    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_cmp(lr_type,
+                      inFd,
+                      checksum_valid,
+                      TRUE, /* use xattr value */
+                      &valid,
+                      &errP);
+
+    if (!ret) {
+      close(inFd);
+      throw libdnf::Error(tfm::format("Error checking checksum %s: (%d, %s)", inPath, errP->code, errP->message));
+    }
+    close(inFd);
+    // gboolean -> bool
+    return valid == TRUE;
+}
+
+std::string checksum_value(const char * type, const char * inPath)
+{
+    GError * errP{nullptr};
+    gboolean valid; /* this is thrown away, we're not checking, we're just calculating it */
+    gchar * calculated = NULL;
+    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,
+                      "",   /* we're calling this to get the file's checksum not compare it */
+                      /**
+                       * https://github.com/rpm-software-management/librepo/issues/233
+                       * We must pass FALSE here because librepo has a simple bug that
+                       * doesn't set calculated if the checksum is cached
+                       */
+                      FALSE,
+                      &valid,
+                      &calculated,
+                      &errP);
+
+    if (!ret) {
+      close(inFd);
+      throw libdnf::Error(tfm::format("Error calculating checksum %s: (%d, %s)", inPath, errP->code, errP->message));
+    }
+    close(inFd);
+    std::string out(calculated);
+    g_free(calculated);
+    return out;
+}
+
 }
 
 namespace numeric {

libdnf/utils/utils.hpp

@@ -66,6 +66,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 {