First stage of improved error handling

Add errror module with error code enumeration and error domains.
Add GError** as param to some functions in xml_dump and repomd modules.

This improved interface is aimed to better (more informative and verbose)
error messages for programs using this library and createrepo_c python
bindings.

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 8c6e526..7889b08 100644 (file)
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,5 +1,6 @@
 SET (createrepo_c_SRCS
      compression_wrapper.c
+     error.c
      load_metadata.c
      locate_metadata.c
      misc.c
@@ -17,6 +18,7 @@ SET(headers
     compression_wrapper.h
     constants.h
     createrepo_c.h
+    error.h
     load_metadata.h
     locate_metadata.h
     misc.h

diff --git a/src/createrepo_c.c b/src/createrepo_c.c
index d52964c..515dcac 100644 (file)
--- a/src/createrepo_c.c
+++ b/src/createrepo_c.c
@@ -262,11 +262,11 @@ dumper_thread(gpointer data, gpointer user_data)
             g_warning("Cannot read package: %s", task->full_path);
             goto task_cleanup;
         }
-        res = cr_xml_dump(pkg);
+        res = cr_xml_dump(pkg, NULL);
     } else {
         // Just gen XML from old loaded metadata
         pkg = md;
-        res = cr_xml_dump(md);
+        res = cr_xml_dump(md, NULL);
     }
 
     g_mutex_lock(udata->mutex_buffer);
@@ -1019,9 +1019,9 @@ main(int argc, char **argv)
 
     // XML
 
-    cr_repomd_record_fill(pri_xml_rec, cmd_options->checksum_type);
-    cr_repomd_record_fill(fil_xml_rec, cmd_options->checksum_type);
-    cr_repomd_record_fill(oth_xml_rec, cmd_options->checksum_type);
+    cr_repomd_record_fill(pri_xml_rec, cmd_options->checksum_type, NULL);
+    cr_repomd_record_fill(fil_xml_rec, cmd_options->checksum_type, NULL);
+    cr_repomd_record_fill(oth_xml_rec, cmd_options->checksum_type, NULL);
 
 
     // Groupfile
@@ -1032,7 +1032,8 @@ main(int argc, char **argv)
         cr_repomd_record_groupfile(groupfile_rec,
                                           compressed_groupfile_rec,
                                           cmd_options->checksum_type,
-                                          groupfile_compression);
+                                          groupfile_compression,
+                                          NULL);
     }
 
 
@@ -1040,7 +1041,7 @@ main(int argc, char **argv)
 
     if (updateinfo) {
         updateinfo_rec = cr_repomd_record_new(updateinfo);
-        cr_repomd_record_fill(updateinfo_rec, cmd_options->checksum_type);
+        cr_repomd_record_fill(updateinfo_rec, cmd_options->checksum_type, NULL);
     }
 
 
@@ -1085,9 +1086,9 @@ main(int argc, char **argv)
         fil_db_rec = cr_repomd_record_new(fil_db_name);
         oth_db_rec = cr_repomd_record_new(oth_db_name);
 
-        cr_repomd_record_fill(pri_db_rec, cmd_options->checksum_type);
-        cr_repomd_record_fill(fil_db_rec, cmd_options->checksum_type);
-        cr_repomd_record_fill(oth_db_rec, cmd_options->checksum_type);
+        cr_repomd_record_fill(pri_db_rec, cmd_options->checksum_type, NULL);
+        cr_repomd_record_fill(fil_db_rec, cmd_options->checksum_type, NULL);
+        cr_repomd_record_fill(oth_db_rec, cmd_options->checksum_type, NULL);
 
         g_free(pri_db_name);
         g_free(fil_db_name);
@@ -1098,15 +1099,15 @@ main(int argc, char **argv)
     // Add checksums into files names
 
     if (cmd_options->unique_md_filenames) {
-        cr_repomd_record_rename_file(pri_xml_rec);
-        cr_repomd_record_rename_file(fil_xml_rec);
-        cr_repomd_record_rename_file(oth_xml_rec);
-        cr_repomd_record_rename_file(pri_db_rec);
-        cr_repomd_record_rename_file(fil_db_rec);
-        cr_repomd_record_rename_file(oth_db_rec);
-        cr_repomd_record_rename_file(groupfile_rec);
-        cr_repomd_record_rename_file(compressed_groupfile_rec);
-        cr_repomd_record_rename_file(updateinfo_rec);
+        cr_repomd_record_rename_file(pri_xml_rec, NULL);
+        cr_repomd_record_rename_file(fil_xml_rec, NULL);
+        cr_repomd_record_rename_file(oth_xml_rec, NULL);
+        cr_repomd_record_rename_file(pri_db_rec, NULL);
+        cr_repomd_record_rename_file(fil_db_rec, NULL);
+        cr_repomd_record_rename_file(oth_db_rec, NULL);
+        cr_repomd_record_rename_file(groupfile_rec, NULL);
+        cr_repomd_record_rename_file(compressed_groupfile_rec, NULL);
+        cr_repomd_record_rename_file(updateinfo_rec, NULL);
     }
 
 

diff --git a/src/createrepo_c.h b/src/createrepo_c.h
index 567db7e..0a15577 100644 (file)
--- a/src/createrepo_c.h
+++ b/src/createrepo_c.h
@@ -42,6 +42,7 @@ extern "C" {
 #include <glib.h>
 #include "compression_wrapper.h"
 #include "constants.h"
+#include "error.h"
 #include "load_metadata.h"
 #include "locate_metadata.h"
 #include "misc.h"

diff --git a/src/error.c b/src/error.c
new file mode 100644 (file)
index 0000000..4df40d1
--- /dev/null
+++ b/src/error.c
@@ -0,0 +1,63 @@
+/* createrepo_c - Library of routines for manipulation with repodata
+ * Copyright (C) 2013      Tomas Mlcoch
+ *
+ * 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; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
+ * USA.
+ */
+
+#include "error.h"
+
+GQuark
+cr_db_error_quark(void)
+{
+    return g_quark_from_static_string("cr_db_error");
+}
+
+GQuark
+cr_xml_dump_primary_error_quark(void)
+{
+    return g_quark_from_static_string("cr_xml_dump_primary_error");
+}
+
+GQuark
+cr_xml_dump_filelists_error_quark(void)
+{
+    return g_quark_from_static_string("cr_xml_dump_filelists_error");
+}
+
+GQuark
+cr_xml_dump_other_error_quark(void)
+{
+    return g_quark_from_static_string("cr_xml_dump_other_error");
+}
+
+GQuark
+cr_repomd_record_error_quark(void)
+{
+    return g_quark_from_static_string("cr_repomd_record_error");
+}
+
+GQuark
+cr_repomd_error_quark(void)
+{
+    return g_quark_from_static_string("cr_repomd_error");
+}
+
+GQuark
+cr_checksum_error_quark(void)
+{
+    return g_quark_from_static_string("cr_checksum_error");
+}
+

diff --git a/src/error.h b/src/error.h
new file mode 100644 (file)
index 0000000..a323daa
--- /dev/null
+++ b/src/error.h
@@ -0,0 +1,60 @@
+/* createrepo_c - Library of routines for manipulation with repodata
+ * Copyright (C) 2013  Tomas Mlcoch
+ *
+ * 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; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
+ * USA.
+ */
+
+#ifndef __C_CREATEREPOLIB_ERROR_H__
+#define __C_CREATEREPOLIB_ERROR_H__
+
+#include <glib.h>
+
+typedef enum {
+    CRE_OK,     /*!<
+        No error */
+    CRE_IO,     /*!<
+        Input/Output error (cannot open file, etc.) */
+    CRE_MEMORY, /*!<
+        Cannot allocate memory */
+    CRE_STAT, /*!<
+        Stat() call failed */
+    CRE_DB,     /*!<
+        A database error */
+    CRE_BADARG, /*!<
+        At least one argument of function is bad or non complete */
+    CRE_NOFILE, /*!<
+        File doesn't exists */
+    CRE_UNKNOWNCHECKSUMTYPE, /*!<
+        Unknown/Unsupported checksum type */
+} cr_Error;
+
+#define CR_DB_ERROR cr_db_error_quark()
+#define CR_XML_DUMP_PRIMARY_ERROR cr_xml_dump_primary_error_quark()
+#define CR_XML_DUMP_FILELISTS_ERROR cr_xml_dump_filelists_error_quark()
+#define CR_XML_DUMP_OTHER_ERROR cr_xml_dump_other_error_quark()
+#define CR_REPOMD_ERROR cr_repomd_error_quark()
+#define CR_REPOMD_RECORD_ERROR cr_repomd_record_error_quark()
+#define CR_CHECKSUM_ERROR cr_checksum_error_quark()
+
+GQuark cr_db_error_quark(void);
+GQuark cr_xml_dump_primary_error_quark(void);
+GQuark cr_xml_dump_filelists_error_quark(void);
+GQuark cr_xml_dump_other_error_quark(void);
+GQuark cr_repomd_error_quark(void);
+GQuark cr_repomd_record_error_quark(void);
+GQuark cr_checksum_error(void);
+
+#endif

diff --git a/src/mergerepo_c.c b/src/mergerepo_c.c
index 2a5561e..65a8a6c 100644 (file)
--- a/src/mergerepo_c.c
+++ b/src/mergerepo_c.c
@@ -1094,7 +1094,7 @@ dump_merged_metadata(GHashTable *merged_hashtable,
             cr_Package *pkg;
 
             pkg = (cr_Package *) element->data;
-            res = cr_xml_dump(pkg);
+            res = cr_xml_dump(pkg, NULL);
 
             cr_puts(pri_f, (const char *) res.primary);
             cr_puts(fil_f, (const char *) res.filelists);
@@ -1160,9 +1160,9 @@ dump_merged_metadata(GHashTable *merged_hashtable,
 
     // XML
 
-    cr_repomd_record_fill(pri_xml_rec, CR_CHECKSUM_SHA256);
-    cr_repomd_record_fill(fil_xml_rec, CR_CHECKSUM_SHA256);
-    cr_repomd_record_fill(oth_xml_rec, CR_CHECKSUM_SHA256);
+    cr_repomd_record_fill(pri_xml_rec, CR_CHECKSUM_SHA256, NULL);
+    cr_repomd_record_fill(fil_xml_rec, CR_CHECKSUM_SHA256, NULL);
+    cr_repomd_record_fill(oth_xml_rec, CR_CHECKSUM_SHA256, NULL);
 
 
     // Groupfile
@@ -1171,9 +1171,10 @@ dump_merged_metadata(GHashTable *merged_hashtable,
         groupfile_rec = cr_repomd_record_new(groupfile);
         compressed_groupfile_rec = cr_repomd_record_new(groupfile);
         cr_repomd_record_groupfile(groupfile_rec,
-                                          compressed_groupfile_rec,
-                                          CR_CHECKSUM_SHA256,
-                                          cmd_options->groupfile_compression_type);
+                                   compressed_groupfile_rec,
+                                   CR_CHECKSUM_SHA256,
+                                   cmd_options->groupfile_compression_type,
+                                   NULL);
     }
 
 
@@ -1181,7 +1182,7 @@ dump_merged_metadata(GHashTable *merged_hashtable,
 
     if (!cmd_options->noupdateinfo) {
         update_info_rec = cr_repomd_record_new(update_info_filename);
-        cr_repomd_record_fill(update_info_rec, CR_CHECKSUM_SHA256);
+        cr_repomd_record_fill(update_info_rec, CR_CHECKSUM_SHA256, NULL);
     }
 
 
@@ -1190,7 +1191,7 @@ dump_merged_metadata(GHashTable *merged_hashtable,
     if (cmd_options->koji) {
         gchar *pkgorigins_path = g_strconcat(cmd_options->tmp_out_repo, "pkgorigins.gz", NULL);
         pkgorigins_rec = cr_repomd_record_new(pkgorigins_path);
-        cr_repomd_record_fill(pkgorigins_rec, CR_CHECKSUM_SHA256);
+        cr_repomd_record_fill(pkgorigins_rec, CR_CHECKSUM_SHA256, NULL);
         g_free(pkgorigins_path);
     }
 
@@ -1244,25 +1245,25 @@ dump_merged_metadata(GHashTable *merged_hashtable,
         g_free(fil_db_c_filename);
         g_free(oth_db_c_filename);
 
-        cr_repomd_record_fill(pri_db_rec, CR_CHECKSUM_SHA256);
-        cr_repomd_record_fill(fil_db_rec, CR_CHECKSUM_SHA256);
-        cr_repomd_record_fill(oth_db_rec, CR_CHECKSUM_SHA256);
+        cr_repomd_record_fill(pri_db_rec, CR_CHECKSUM_SHA256, NULL);
+        cr_repomd_record_fill(fil_db_rec, CR_CHECKSUM_SHA256, NULL);
+        cr_repomd_record_fill(oth_db_rec, CR_CHECKSUM_SHA256, NULL);
     }
 
 
     // Add checksums into files names
 
     if (cmd_options->unique_md_filenames) {
-        cr_repomd_record_rename_file(pri_xml_rec);
-        cr_repomd_record_rename_file(fil_xml_rec);
-        cr_repomd_record_rename_file(oth_xml_rec);
-        cr_repomd_record_rename_file(pri_db_rec);
-        cr_repomd_record_rename_file(fil_db_rec);
-        cr_repomd_record_rename_file(oth_db_rec);
-        cr_repomd_record_rename_file(groupfile_rec);
-        cr_repomd_record_rename_file(compressed_groupfile_rec);
-        cr_repomd_record_rename_file(update_info_rec);
-        cr_repomd_record_rename_file(pkgorigins_rec);
+        cr_repomd_record_rename_file(pri_xml_rec, NULL);
+        cr_repomd_record_rename_file(fil_xml_rec, NULL);
+        cr_repomd_record_rename_file(oth_xml_rec, NULL);
+        cr_repomd_record_rename_file(pri_db_rec, NULL);
+        cr_repomd_record_rename_file(fil_db_rec, NULL);
+        cr_repomd_record_rename_file(oth_db_rec, NULL);
+        cr_repomd_record_rename_file(groupfile_rec, NULL);
+        cr_repomd_record_rename_file(compressed_groupfile_rec, NULL);
+        cr_repomd_record_rename_file(update_info_rec, NULL);
+        cr_repomd_record_rename_file(pkgorigins_rec, NULL);
     }
 
 

diff --git a/src/misc.c b/src/misc.c
index 1910c33..db08eae 100644 (file)
--- a/src/misc.c
+++ b/src/misc.c
@@ -20,6 +20,7 @@
 #define _XOPEN_SOURCE 500
 
 #include <glib.h>
+#include <assert.h>
 #include <errno.h>
 #include <stdio.h>
 #include <string.h>
@@ -30,6 +31,7 @@
 #include <time.h>
 #include <curl/curl.h>
 #include <rpm/rpmlib.h>
+#include "error.h"
 #include "logging.h"
 #include "constants.h"
 #include "misc.h"
@@ -218,19 +220,21 @@ cr_is_primary(const char *filename)
 
 
 char *
-cr_compute_file_checksum(const char *filename, cr_ChecksumType type)
+cr_compute_file_checksum(const char *filename,
+                         cr_ChecksumType type,
+                         GError **err)
 {
     GChecksumType gchecksumtype;
 
-    if (!filename) {
-        g_debug("%s: Filename param is NULL", __func__);
-        return NULL;
-    }
+    assert(filename);
+    assert(!err || *err == NULL);
 
     // Check if file exists and if it is a regular file (not a directory)
 
     if (!g_file_test(filename, (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR))) {
         g_debug("%s: File %s doesn't exists", __func__, filename);
+        g_set_error(err, CR_CHECKSUM_ERROR, CRE_NOFILE,
+                    "File %s doesn't exists", filename);
         return NULL;
     }
 
@@ -249,6 +253,8 @@ cr_compute_file_checksum(const char *filename, cr_ChecksumType type)
             break;
         default:
             g_debug("%s: Unknown checksum type", __func__);
+            g_set_error(err, CR_CHECKSUM_ERROR, CRE_UNKNOWNCHECKSUMTYPE,
+                        "Unknown checksum type: %d", type);
             return NULL;
     };
 
@@ -259,6 +265,8 @@ cr_compute_file_checksum(const char *filename, cr_ChecksumType type)
     if (!fp) {
         g_critical("%s: Cannot open %s (%s)", __func__, filename,
                                                     strerror(errno));
+        g_set_error(err, CR_CHECKSUM_ERROR, CRE_IO,
+                    "Cannot open %s: %s", filename, strerror(errno));
         return NULL;
     }
 
@@ -278,6 +286,14 @@ cr_compute_file_checksum(const char *filename, cr_ChecksumType type)
         }
     }
 
+    if (ferror(fp)) {
+        g_set_error(err, CR_CHECKSUM_ERROR, CRE_IO,
+                    "fread call faied: %s", strerror(errno));
+        fclose(fp);
+        g_checksum_free(checksum);
+        return NULL;
+    }
+
     fclose(fp);
 
 
@@ -289,6 +305,8 @@ cr_compute_file_checksum(const char *filename, cr_ChecksumType type)
     if (!checksum_str) {
         g_critical("%s: Cannot get checksum %s (low memory?)", __func__,
                    filename);
+        g_set_error(err, CR_CHECKSUM_ERROR, CRE_MEMORY,
+                    "Cannot calculate checksum (low memory?)");
     }
 
     return checksum_str;

diff --git a/src/misc.h b/src/misc.h
index ee6b486..c1d7f56 100644 (file)
--- a/src/misc.h
+++ b/src/misc.h
@@ -102,10 +102,13 @@ static inline int cr_is_primary(const char *filename) {
 /** Compute file checksum.
  * @param filename      filename
  * @param type          type of checksum
+ * @param err           GError **
  * @return              malloced null terminated string with checksum
  *                      or NULL on error
  */
-char *cr_compute_file_checksum(const char *filename, cr_ChecksumType type);
+char *cr_compute_file_checksum(const char *filename,
+                               cr_ChecksumType type,
+                               GError **err);
 
 /** Header range
  */

diff --git a/src/parsehdr.c b/src/parsehdr.c
index 1955007..5f694bb 100644 (file)
--- a/src/parsehdr.c
+++ b/src/parsehdr.c
@@ -537,9 +537,9 @@ cr_xml_from_header(Header hdr, gint64 mtime, gint64 size,
                                       changelog_limit, hdr_start, hdr_end);
 
     struct cr_XmlStruct result;
-    result.primary   = cr_xml_dump_primary(pkg);
-    result.filelists = cr_xml_dump_filelists(pkg);
-    result.other     = cr_xml_dump_other(pkg);
+    result.primary   = cr_xml_dump_primary(pkg, NULL);
+    result.filelists = cr_xml_dump_filelists(pkg, NULL);
+    result.other     = cr_xml_dump_other(pkg, NULL);
 
     // Cleanup
     cr_package_free(pkg);

diff --git a/src/parsepkg.c b/src/parsepkg.c
index 2ce3fd3..b782142 100644 (file)
--- a/src/parsepkg.c
+++ b/src/parsepkg.c
@@ -31,7 +31,6 @@
 #include "logging.h"
 #include "constants.h"
 #include "parsehdr.h"
-#include "xml_dump.h"
 #include "misc.h"
 #include "parsehdr.h"
 
@@ -158,7 +157,7 @@ cr_package_from_rpm(const char *filename,
 
     // Compute checksum
 
-    char *checksum = cr_compute_file_checksum(filename, checksum_type);
+    char *checksum = cr_compute_file_checksum(filename, checksum_type, NULL);
 
 
     // Get header range
@@ -276,7 +275,7 @@ cr_xml_from_rpm(const char *filename,
 
     // Compute checksum
 
-    char *checksum = cr_compute_file_checksum(filename, checksum_type);
+    char *checksum = cr_compute_file_checksum(filename, checksum_type, NULL);
 
 
     // Get header range

diff --git a/src/python/repomdrecord-py.c b/src/python/repomdrecord-py.c
index aa2afd5..11d4a0a 100644 (file)
--- a/src/python/repomdrecord-py.c
+++ b/src/python/repomdrecord-py.c
@@ -112,11 +112,21 @@ static PyObject *
 fill(_RepomdRecordObject *self, PyObject *args)
 {
     int checksum_type;
+    GError *err = NULL;
+
     if (!PyArg_ParseTuple(args, "i:fill", &checksum_type))
         return NULL;
+
     if (check_RepomdRecordStatus(self))
         return NULL;
-    cr_repomd_record_fill(self->record, checksum_type);
+
+    cr_repomd_record_fill(self->record, checksum_type, &err);
+    if (err) {
+        PyErr_Format(CrErr_Exception, "fill method failed: %s", err->message);
+        g_clear_error(&err);
+        return NULL;
+    }
+
     Py_RETURN_NONE;
 }
 
@@ -125,26 +135,46 @@ compress_and_fill(_RepomdRecordObject *self, PyObject *args)
 {
     int checksum_type, compression_type;
     PyObject *compressed_repomdrecord;
+    GError *err = NULL;
+
     if (!PyArg_ParseTuple(args, "O!ii:fill",
                           &RepomdRecord_Type,
                           &compressed_repomdrecord,
                           &checksum_type,
                           &compression_type))
         return NULL;
+
     if (check_RepomdRecordStatus(self))
         return NULL;
+
     cr_repomd_record_groupfile(self->record,
                                RepomdRecord_FromPyObject(compressed_repomdrecord),
                                checksum_type,
-                               compression_type);
+                               compression_type,
+                               &err);
+    if (err) {
+        PyErr_Format(CrErr_Exception, "compress_and_fill method failed: %s", err->message);
+        g_clear_error(&err);
+        return NULL;
+    }
+
     Py_RETURN_NONE;
 }
 
 static PyObject *
 rename_file(_RepomdRecordObject *self, void *nothing)
 {
+    GError *err = NULL;
+
     CR_UNUSED(nothing);
-    cr_repomd_record_rename_file(self->record);
+
+    cr_repomd_record_rename_file(self->record, &err);
+    if (err) {
+        PyErr_Format(CrErr_Exception, "rename_file method failed: %s", err->message);
+        g_clear_error(&err);
+        return NULL;
+    }
+
     Py_RETURN_NONE;
 }
 

diff --git a/src/python/xml_dump-py.c b/src/python/xml_dump-py.c
index 0654193..e4a4141 100644 (file)
--- a/src/python/xml_dump-py.c
+++ b/src/python/xml_dump-py.c
@@ -30,12 +30,23 @@
 PyObject *
 py_xml_dump_primary(PyObject *self, PyObject *args)
 {
-    CR_UNUSED(self);
     PyObject *py_pkg, *py_str;
     char *xml;
+    GError *err = NULL;
+
+    CR_UNUSED(self);
+
     if (!PyArg_ParseTuple(args, "O!:py_xml_dump_primary", &Package_Type, &py_pkg))
         return NULL;
-    xml = cr_xml_dump_primary(Package_FromPyObject(py_pkg));
+
+    xml = cr_xml_dump_primary(Package_FromPyObject(py_pkg), &err);
+    if (err) {
+        PyErr_Format(CrErr_Exception, "Error while dumping primary xml: %s",
+                     err->message);
+        g_clear_error(&err);
+        return NULL;
+    }
+
     py_str = PyStringOrNone_FromString(xml);
     free(xml);
     return py_str;
@@ -44,12 +55,23 @@ py_xml_dump_primary(PyObject *self, PyObject *args)
 PyObject *
 py_xml_dump_filelists(PyObject *self, PyObject *args)
 {
-    CR_UNUSED(self);
     PyObject *py_pkg, *py_str;
     char *xml;
+    GError *err = NULL;
+
+    CR_UNUSED(self);
+
     if (!PyArg_ParseTuple(args, "O!:py_xml_dump_filelists", &Package_Type, &py_pkg))
         return NULL;
-    xml = cr_xml_dump_filelists(Package_FromPyObject(py_pkg));
+
+    xml = cr_xml_dump_filelists(Package_FromPyObject(py_pkg), &err);
+    if (err) {
+        PyErr_Format(CrErr_Exception, "Error while dumping filelists xml: %s",
+                     err->message);
+        g_clear_error(&err);
+        return NULL;
+    }
+
     py_str = PyStringOrNone_FromString(xml);
     free(xml);
     return py_str;
@@ -58,12 +80,23 @@ py_xml_dump_filelists(PyObject *self, PyObject *args)
 PyObject *
 py_xml_dump_other(PyObject *self, PyObject *args)
 {
-    CR_UNUSED(self);
     PyObject *py_pkg, *py_str;
     char *xml;
+    GError *err = NULL;
+
+    CR_UNUSED(self);
+
     if (!PyArg_ParseTuple(args, "O!:py_xml_dump_other", &Package_Type, &py_pkg))
         return NULL;
-    xml = cr_xml_dump_other(Package_FromPyObject(py_pkg));
+
+    xml = cr_xml_dump_other(Package_FromPyObject(py_pkg), &err);
+    if (err) {
+        PyErr_Format(CrErr_Exception, "Error while dumping other xml: %s",
+                     err->message);
+        g_clear_error(&err);
+        return NULL;
+    }
+
     py_str = PyStringOrNone_FromString(xml);
     free(xml);
     return py_str;
@@ -72,17 +105,30 @@ py_xml_dump_other(PyObject *self, PyObject *args)
 PyObject *
 py_xml_dump(PyObject *self, PyObject *args)
 {
-    CR_UNUSED(self);
     PyObject *py_pkg, *tuple;
     struct cr_XmlStruct xml_res;
+    GError *err = NULL;
+
+    CR_UNUSED(self);
 
     if (!PyArg_ParseTuple(args, "O!:py_xml_dump", &Package_Type, &py_pkg))
         return NULL;
 
-    if ((tuple = PyTuple_New(3)) == NULL)
+
+    xml_res = cr_xml_dump(Package_FromPyObject(py_pkg), &err);
+    if (err) {
+        PyErr_Format(CrErr_Exception, "Error while dumping xml: %s",
+                     err->message);
+        g_clear_error(&err);
         return NULL;
+    }
 
-    xml_res = cr_xml_dump(Package_FromPyObject(py_pkg));
+    if ((tuple = PyTuple_New(3)) == NULL) {
+        free(xml_res.primary);
+        free(xml_res.filelists);
+        free(xml_res.other);
+        return NULL;
+    }
 
     PyTuple_SetItem(tuple, 0, PyStringOrNone_FromString(xml_res.primary));
     PyTuple_SetItem(tuple, 1, PyStringOrNone_FromString(xml_res.filelists));

diff --git a/src/repomd.c b/src/repomd.c
index b356e73..5812ebd 100644 (file)
--- a/src/repomd.c
+++ b/src/repomd.c
@@ -18,6 +18,7 @@
  */
 
 #include <glib.h>
+#include <errno.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <time.h>
@@ -25,6 +26,7 @@
 #include <assert.h>
 #include <libxml/encoding.h>
 #include <libxml/xmlwriter.h>
+#include "error.h"
 #include "logging.h"
 #include "misc.h"
 #include "repomd.h"
@@ -43,8 +45,8 @@
 #define XML_ENC         "UTF-8"
 #define FORMAT_XML      1
 
-#define REPOMD_OK       0
-#define REPOMD_ERR      1
+#define REPOMD_OK       0 // XXX
+#define REPOMD_ERR      1 // XXX
 
 
 typedef struct _contentStat {
@@ -106,9 +108,16 @@ cr_repomd_record_free(cr_RepomdRecord md)
 
 
 contentStat *
-cr_get_compressed_content_stat(const char *filename, cr_ChecksumType checksum_type)
+cr_get_compressed_content_stat(const char *filename,
+                               cr_ChecksumType checksum_type,
+                               GError **err)
 {
+    assert(filename);
+    assert(!err || *err == NULL);
+
     if (!g_file_test(filename, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
+        g_set_error(err, CR_REPOMD_RECORD_ERROR, CRE_NOFILE,
+                    "File doesn't exists");
         return NULL;
     }
 
@@ -117,6 +126,8 @@ cr_get_compressed_content_stat(const char *filename, cr_ChecksumType checksum_ty
 
     CR_FILE *cwfile;
     if (!(cwfile = cr_open(filename, CR_CW_MODE_READ, CR_CW_AUTO_DETECT_COMPRESSION))) {
+        g_set_error(err, CR_REPOMD_RECORD_ERROR, CRE_IO,
+                    "Cannot open a file");
         return NULL;
     }
 
@@ -136,6 +147,8 @@ cr_get_compressed_content_stat(const char *filename, cr_ChecksumType checksum_ty
             break;
         default:
             g_critical("%s: Unknown checksum type", __func__);
+            g_set_error(err, CR_REPOMD_RECORD_ERROR, CRE_UNKNOWNCHECKSUMTYPE,
+                        "Unknown checksum type: %d", checksum_type);
             return NULL;
     };
 
@@ -145,6 +158,8 @@ cr_get_compressed_content_stat(const char *filename, cr_ChecksumType checksum_ty
     GChecksum *checksum = g_checksum_new(gchecksumtype);
     if (!checksum) {
         g_critical("%s: g_checksum_new() failed", __func__);
+        g_set_error(err, CR_REPOMD_RECORD_ERROR, CRE_UNKNOWNCHECKSUMTYPE,
+                    "g_checksum_new() failed - Unknown checksum type");
         return NULL;
     }
 
@@ -157,12 +172,16 @@ cr_get_compressed_content_stat(const char *filename, cr_ChecksumType checksum_ty
         if (readed == CR_CW_ERR) {
             g_debug("%s: Error while read compressed file: %s",
                     __func__, filename);
+            g_set_error(err, CR_REPOMD_RECORD_ERROR, CRE_IO,
+                        "Error while read compressed file");
             break;
         }
         g_checksum_update (checksum, buffer, readed);
         size += readed;
     } while (readed == BUFFER_SIZE);
 
+    if (readed == CR_CW_ERR)
+        return NULL;
 
     // Create result structure
 
@@ -170,6 +189,9 @@ cr_get_compressed_content_stat(const char *filename, cr_ChecksumType checksum_ty
     if (result) {
         result->checksum = g_strdup(g_checksum_get_string(checksum));
         result->size = size;
+    } else {
+        g_set_error(err, CR_REPOMD_RECORD_ERROR, CRE_MEMORY,
+                    "Cannot allocate memory");
     }
 
 
@@ -184,15 +206,22 @@ cr_get_compressed_content_stat(const char *filename, cr_ChecksumType checksum_ty
 
 
 int
-cr_repomd_record_fill(cr_RepomdRecord md, cr_ChecksumType checksum_type)
+cr_repomd_record_fill(cr_RepomdRecord md,
+                      cr_ChecksumType checksum_type,
+                      GError **err)
 {
     const char *checksum_str;
     cr_ChecksumType checksum_t;
     gchar *path;
+    GError *tmp_err = NULL;
 
-    if (!md || !(md->location_real) || !strlen(md->location_real)) {
-        // Nothing to do
-        return REPOMD_ERR;
+    assert(!err || *err == NULL);
+    assert(md);
+
+    if (!(md->location_real) || !strlen(md->location_real)) {
+        g_set_error(err, CR_REPOMD_RECORD_ERROR, CRE_BADARG,
+                    "Empty locations in repomd record object.");
+        return CRE_BADARG;
     }
 
     path = md->location_real;
@@ -203,7 +232,9 @@ cr_repomd_record_fill(cr_RepomdRecord md, cr_ChecksumType checksum_type)
     if (!g_file_test(path, G_FILE_TEST_EXISTS|G_FILE_TEST_IS_REGULAR)) {
         // File doesn't exists
         g_warning("%s: File %s doesn't exists", __func__, path);
-        return REPOMD_ERR;
+        g_set_error(err, CR_REPOMD_RECORD_ERROR, CRE_NOFILE,
+                    "File %s doesn't exists", path);
+        return CRE_NOFILE;
     }
 
 
@@ -211,8 +242,15 @@ cr_repomd_record_fill(cr_RepomdRecord md, cr_ChecksumType checksum_type)
 
     if (!md->checksum_type || !md->checksum) {
         gchar *chksum;
+
+        chksum = cr_compute_file_checksum(path, checksum_t, &tmp_err);
+        if (tmp_err) {
+            g_propagate_prefixed_error(err, tmp_err,
+                "Error while checksum calculation of %s:", path);
+            return (*err)->code;
+        }
+
         md->checksum_type = g_string_chunk_insert(md->chunk, checksum_str);
-        chksum = cr_compute_file_checksum(path, checksum_t);
         md->checksum = g_string_chunk_insert(md->chunk, chksum);
         g_free(chksum);
     }
@@ -226,12 +264,19 @@ cr_repomd_record_fill(cr_RepomdRecord md, cr_ChecksumType checksum_type)
         {
             // File compressed by supported algorithm
             contentStat *open_stat = NULL;
-            open_stat = cr_get_compressed_content_stat(path, checksum_t);
+
+            open_stat = cr_get_compressed_content_stat(path, checksum_t, &tmp_err);
+            if (tmp_err) {
+                g_propagate_prefixed_error(err, tmp_err,
+                    "Error while computing stat of compressed content of %s:",
+                    path);
+                return (*err)->code;
+            }
+
             md->checksum_open_type = g_string_chunk_insert(md->chunk, checksum_str);
             md->checksum_open = g_string_chunk_insert(md->chunk, open_stat->checksum);
-            if (!md->size_open) {
+            if (!md->size_open)
                 md->size_open = open_stat->size;
-            }
             g_free(open_stat->checksum);
             g_free(open_stat);
         } else {
@@ -259,25 +304,28 @@ cr_repomd_record_fill(cr_RepomdRecord md, cr_ChecksumType checksum_type)
             }
         } else {
             g_warning("%s: Stat on file \"%s\" failed", __func__, path);
+            g_set_error(err, CR_REPOMD_RECORD_ERROR, CRE_STAT,
+                        "Stat() on %s failed: %s", path, strerror(errno));
+            return CRE_STAT;
         }
     }
 
 
     // Set db version
 
-    if (!md->db_ver) {
+    if (!md->db_ver)
         md->db_ver = DEFAULT_DATABASE_VERSION;
-    }
 
-    return REPOMD_OK;
+    return CRE_OK;
 }
 
 
 void
 cr_repomd_record_groupfile(cr_RepomdRecord groupfile,
-                                  cr_RepomdRecord cgroupfile,
-                                  cr_ChecksumType checksum_type,
-                                  cr_CompressionType groupfile_compression)
+                           cr_RepomdRecord cgroupfile,
+                           cr_ChecksumType checksum_type,
+                           cr_CompressionType groupfile_compression,
+                           GError **err)
 {
     const char *suffix;
     gchar *path, *cpath;
@@ -350,8 +398,8 @@ cr_repomd_record_groupfile(cr_RepomdRecord groupfile,
 
     // Compute checksums
 
-    checksum  = cr_compute_file_checksum(path, checksum_t);
-    cchecksum = cr_compute_file_checksum(cpath, checksum_t);
+    checksum  = cr_compute_file_checksum(path, checksum_t, NULL);
+    cchecksum = cr_compute_file_checksum(cpath, checksum_t, NULL);
 
 
     // Get stats
@@ -528,7 +576,7 @@ cr_repomd_xml_dump(cr_Repomd repomd)
 
 
 void
-cr_repomd_record_rename_file(cr_RepomdRecord md)
+cr_repomd_record_rename_file(cr_RepomdRecord md, GError **err)
 {
     int x, len;
     gchar *location_prefix = NULL;

diff --git a/src/repomd.h b/src/repomd.h
index 4576125..fa960b6 100644 (file)
--- a/src/repomd.h
+++ b/src/repomd.h
@@ -115,9 +115,12 @@ void cr_repomd_record_free(cr_RepomdRecord record);
  * Note: For groupfile you shoud use cr_repomd_record_groupfile function.
  * @param record                cr_RepomdRecord object
  * @param checksum_type         type of checksum to use
+ * @param err                   GError **
+ * @return                      cr_Error code
  */
 int cr_repomd_record_fill(cr_RepomdRecord record,
-                          cr_ChecksumType checksum_type);
+                          cr_ChecksumType checksum_type,
+                          GError **err);
 
 /** Analogue of cr_repomd_record_fill but for groupfile.
  * Groupfile must be set with the path to existing non compressed groupfile.
@@ -128,16 +131,19 @@ int cr_repomd_record_fill(cr_RepomdRecord record,
  * @param compressed_groupfile  empty cr_RepomdRecord object that will by filled
  * @param checksum_type         type of checksums
  * @param compression           type of compression
+ * @param err                   GError **
  */
 void cr_repomd_record_groupfile(cr_RepomdRecord groupfile,
                                 cr_RepomdRecord compressed_groupfile,
                                 cr_ChecksumType checksum_type,
-                                cr_CompressionType compression);
+                                cr_CompressionType compression,
+                                GError **err);
 
 /** Add a hash as prefix to the filename.
  * @param record                cr_RepomdRecord of file to be renamed
+ * @param err                   GError **
  */
-void cr_repomd_record_rename_file(cr_RepomdRecord record);
+void cr_repomd_record_rename_file(cr_RepomdRecord record, GError **err);
 
 /** Create new empty cr_Repomd object wich represents content of repomd.xml.
  */

diff --git a/src/sqlite.c b/src/sqlite.c
index 6aa314d..b0da72c 100644 (file)
--- a/src/sqlite.c
+++ b/src/sqlite.c
@@ -28,23 +28,11 @@
 #include "logging.h"
 #include "misc.h"
 #include "sqlite.h"
+#include "error.h"
 
 #define ENCODED_PACKAGE_FILE_FILES 2048
 #define ENCODED_PACKAGE_FILE_TYPES 60
 
-
-GQuark
-cr_db_error_quark(void)
-{
-    static GQuark quark;
-
-    if (!quark)
-        quark = g_quark_from_static_string("cr_db_error");
-
-    return quark;
-}
-
-
 struct _DbPrimaryStatements {
     sqlite3 *db;
     sqlite3_stmt *pkg_handle;
@@ -85,7 +73,7 @@ open_sqlite_db(const char *path, GError **err)
 
     rc = sqlite3_open(path, &db);
     if (rc != SQLITE_OK) {
-        g_set_error(err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                     "Can not open SQL database: %s", sqlite3_errmsg(db));
         sqlite3_close(db);
         db = NULL;
@@ -104,7 +92,7 @@ db_create_dbinfo_table(sqlite3 *db, GError **err)
     sql = "CREATE TABLE db_info (dbversion INTEGER, checksum TEXT)";
     rc = sqlite3_exec(db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error(err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                     "Can not create db_info table: %s",
                      sqlite3_errmsg (db));
     }
@@ -148,7 +136,7 @@ db_create_primary_tables(sqlite3 *db, GError **err)
 
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create packages table: %s",
                      sqlite3_errmsg (db));
         return;
@@ -161,7 +149,7 @@ db_create_primary_tables(sqlite3 *db, GError **err)
         "  pkgKey INTEGER)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create files table: %s",
                      sqlite3_errmsg (db));
         return;
@@ -193,7 +181,7 @@ db_create_primary_tables(sqlite3 *db, GError **err)
         g_free (query);
 
         if (rc != SQLITE_OK) {
-            g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+            g_set_error(err, CR_DB_ERROR, CRE_DB,
                          "Can not create %s table: %s",
                          deps[i], sqlite3_errmsg (db));
             return;
@@ -212,7 +200,7 @@ db_create_primary_tables(sqlite3 *db, GError **err)
 
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create removals trigger: %s",
                      sqlite3_errmsg (db));
         return;
@@ -232,7 +220,7 @@ db_create_filelists_tables(sqlite3 *db, GError **err)
         "  pkgId TEXT)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create packages table: %s",
                      sqlite3_errmsg (db));
         return;
@@ -246,7 +234,7 @@ db_create_filelists_tables(sqlite3 *db, GError **err)
         "  filetypes TEXT)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create filelist table: %s",
                      sqlite3_errmsg (db));
         return;
@@ -260,7 +248,7 @@ db_create_filelists_tables(sqlite3 *db, GError **err)
 
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create remove_filelist trigger: %s",
                      sqlite3_errmsg (db));
         return;
@@ -280,7 +268,7 @@ db_create_other_tables (sqlite3 *db, GError **err)
         "  pkgId TEXT)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create packages table: %s",
                      sqlite3_errmsg (db));
         return;
@@ -294,7 +282,7 @@ db_create_other_tables (sqlite3 *db, GError **err)
         "  changelog TEXT)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create changelog table: %s",
                      sqlite3_errmsg (db));
         return;
@@ -308,7 +296,7 @@ db_create_other_tables (sqlite3 *db, GError **err)
 
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create remove_changelogs trigger: %s",
                      sqlite3_errmsg (db));
         return;
@@ -341,7 +329,7 @@ db_index_primary_tables (sqlite3 *db, GError **err)
     sql = "CREATE INDEX IF NOT EXISTS packagename ON packages (name)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create packagename index: %s",
                      sqlite3_errmsg (db));
         return;
@@ -350,7 +338,7 @@ db_index_primary_tables (sqlite3 *db, GError **err)
     sql = "CREATE INDEX IF NOT EXISTS packageId ON packages (pkgId)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create packageId index: %s",
                      sqlite3_errmsg (db));
         return;
@@ -359,7 +347,7 @@ db_index_primary_tables (sqlite3 *db, GError **err)
     sql = "CREATE INDEX IF NOT EXISTS filenames ON files (name)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create filenames index: %s",
                      sqlite3_errmsg (db));
         return;
@@ -368,7 +356,7 @@ db_index_primary_tables (sqlite3 *db, GError **err)
     sql = "CREATE INDEX IF NOT EXISTS pkgfiles ON files (pkgKey)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create index on files table: %s",
                      sqlite3_errmsg (db));
         return;
@@ -393,7 +381,7 @@ db_index_primary_tables (sqlite3 *db, GError **err)
         g_free (query);
 
         if (rc != SQLITE_OK) {
-            g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+            g_set_error(err, CR_DB_ERROR, CRE_DB,
                          "Can not create index on %s table: %s",
                          deps[i], sqlite3_errmsg (db));
             return;
@@ -404,7 +392,7 @@ db_index_primary_tables (sqlite3 *db, GError **err)
             rc = sqlite3_exec (db, query, NULL, NULL, NULL);
             g_free(query);
             if (rc != SQLITE_OK) {
-                g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+                g_set_error(err, CR_DB_ERROR, CRE_DB,
                              "Can not create %sname index: %s",
                              deps[i], sqlite3_errmsg (db));
                 return;
@@ -423,7 +411,7 @@ db_index_filelists_tables (sqlite3 *db, GError **err)
     sql = "CREATE INDEX IF NOT EXISTS keyfile ON filelist (pkgKey)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create keyfile index: %s",
                      sqlite3_errmsg (db));
         return;
@@ -432,7 +420,7 @@ db_index_filelists_tables (sqlite3 *db, GError **err)
     sql = "CREATE INDEX IF NOT EXISTS pkgId ON packages (pkgId)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create pkgId index: %s",
                      sqlite3_errmsg (db));
         return;
@@ -441,7 +429,7 @@ db_index_filelists_tables (sqlite3 *db, GError **err)
     sql = "CREATE INDEX IF NOT EXISTS dirnames ON filelist (dirname)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create dirnames index: %s",
                      sqlite3_errmsg (db));
         return;
@@ -458,7 +446,7 @@ db_index_other_tables (sqlite3 *db, GError **err)
     sql = "CREATE INDEX IF NOT EXISTS keychange ON changelog (pkgKey)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create keychange index: %s",
                      sqlite3_errmsg (db));
         return;
@@ -467,7 +455,7 @@ db_index_other_tables (sqlite3 *db, GError **err)
     sql = "CREATE INDEX IF NOT EXISTS pkgId ON packages (pkgId)";
     rc = sqlite3_exec (db, sql, NULL, NULL, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not create pkgId index: %s",
                      sqlite3_errmsg (db));
         return;
@@ -569,7 +557,7 @@ cr_db_dbinfo_update(sqlite3 *db, const char *checksum, GError **err)
     /* Prepare insert statement */
     rc = sqlite3_prepare_v2(db, query, -1, &handle, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error(err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                     "Cannot prepare db_info update: %s",
                     sqlite3_errmsg(db));
         g_critical("%s: Cannot prepare db_info update statement: %s",
@@ -588,7 +576,7 @@ cr_db_dbinfo_update(sqlite3 *db, const char *checksum, GError **err)
     rc = sqlite3_finalize(handle);
 
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                       "Cannot update dbinfo table: %s",
                        sqlite3_errmsg (db));
         g_critical("%s: Cannot update dbinfo table: %s",
@@ -622,7 +610,7 @@ db_package_prepare (sqlite3 *db, GError **err)
 
     rc = sqlite3_prepare_v2 (db, query, -1, &handle, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Cannot prepare packages insertion: %s",
                      sqlite3_errmsg (db));
         sqlite3_finalize (handle);
@@ -694,7 +682,7 @@ db_package_write (sqlite3 *db,
     } else {
         g_critical ("Error adding package to db: %s",
                     sqlite3_errmsg(db));
-        g_set_error(err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                     "Error adding package to db: %s",
                     sqlite3_errmsg(db));
     }
@@ -724,7 +712,7 @@ db_dependency_prepare (sqlite3 *db, const char *table, GError **err)
     g_free (query);
 
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Cannot prepare dependency insertion: %s",
                      sqlite3_errmsg (db));
         sqlite3_finalize (handle);
@@ -764,7 +752,7 @@ db_dependency_write (sqlite3 *db,
     if (rc != SQLITE_DONE) {
         g_critical ("Error adding package dependency to db: %s",
                     sqlite3_errmsg (db));
-        g_set_error(err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                     "Error adding package dependency to db: %s",
                     sqlite3_errmsg(db));
     }
@@ -781,7 +769,7 @@ db_file_prepare (sqlite3 *db, GError **err)
 
     rc = sqlite3_prepare_v2 (db, query, -1, &handle, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not prepare file insertion: %s",
                      sqlite3_errmsg (db));
         sqlite3_finalize (handle);
@@ -826,7 +814,7 @@ db_file_write (sqlite3 *db,
     if (rc != SQLITE_DONE) {
         g_critical ("Error adding package file to db: %s",
                     sqlite3_errmsg (db));
-        g_set_error(err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                     "Error adding package file to db: %s",
                     sqlite3_errmsg(db));
     }
@@ -851,7 +839,7 @@ db_filelists_prepare (sqlite3 *db, GError **err)
 
     rc = sqlite3_prepare_v2 (db, query, -1, &handle, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not prepare filelist insertion: %s",
                      sqlite3_errmsg (db));
         sqlite3_finalize (handle);
@@ -978,7 +966,7 @@ cr_db_write_file (sqlite3 *db,
     if (rc != SQLITE_DONE) {
         g_critical ("Error adding file records to db: %s",
                     sqlite3_errmsg (db));
-        g_set_error(err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                     "Error adding file records to db : %s",
                      sqlite3_errmsg(db));
     }
@@ -1003,7 +991,7 @@ db_changelog_prepare (sqlite3 *db, GError **err)
 
     rc = sqlite3_prepare_v2 (db, query, -1, &handle, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not prepare changelog insertion: %s",
                      sqlite3_errmsg (db));
         sqlite3_finalize (handle);
@@ -1027,7 +1015,7 @@ db_package_ids_prepare(sqlite3 *db, GError **err)
     query = "INSERT INTO packages (pkgId) VALUES (?)";
     rc = sqlite3_prepare_v2 (db, query, -1, &handle, NULL);
     if (rc != SQLITE_OK) {
-        g_set_error (err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                      "Can not prepare package ids insertion: %s",
                       sqlite3_errmsg (db));
         sqlite3_finalize (handle);
@@ -1054,7 +1042,7 @@ db_package_ids_write(sqlite3 *db,
     } else {
         g_critical("Error adding package to db: %s",
                    sqlite3_errmsg(db));
-        g_set_error(err, CR_DB_ERROR, CR_DB_ERROR,
+        g_set_error(err, CR_DB_ERROR, CRE_DB,
                     "Error adding package to db: %s",
                     sqlite3_errmsg(db));
     }
@@ -1374,7 +1362,7 @@ cr_db_add_other_pkg(cr_DbOtherStatements stmts, cr_Package *pkg, GError **err)
         if (rc != SQLITE_DONE) {
             g_critical ("Error adding changelog to db: %s",
                         sqlite3_errmsg (stmts->db));
-            g_set_error(err, CR_DB_ERROR, CR_DB_ERROR,
+            g_set_error(err, CR_DB_ERROR, CRE_DB,
                         "Error adding changelog to db : %s",
                         sqlite3_errmsg(stmts->db));
             return;

diff --git a/src/sqlite.h b/src/sqlite.h
index f13246e..0af0968 100644 (file)
--- a/src/sqlite.h
+++ b/src/sqlite.h
@@ -62,9 +62,6 @@ extern "C" {
 
 #define CR_DB_CACHE_DBVERSION       10      /*!< Version of DB api */
 
-#define CR_DB_ERROR cr_db_error_quark()
-GQuark cr_db_error_quark (void);
-
 typedef struct _DbPrimaryStatements   * cr_DbPrimaryStatements;
 typedef struct _DbFilelistsStatements * cr_DbFilelistsStatements;
 typedef struct _DbOtherStatements     * cr_DbOtherStatements;

diff --git a/src/xml_dump.c b/src/xml_dump.c
index 5f4b126..f949c53 100644 (file)
--- a/src/xml_dump.c
+++ b/src/xml_dump.c
@@ -18,10 +18,12 @@
  */
 
 #include <glib.h>
+#include <assert.h>
 #include <libxml/encoding.h>
 #include <libxml/xmlwriter.h>
 #include <libxml/parser.h>
 #include <string.h>
+#include "error.h"
 #include "logging.h"
 #include "misc.h"
 #include "xml_dump.h"
@@ -177,9 +179,12 @@ cr_xml_dump_files(xmlNodePtr node, cr_Package *package, int primary)
 
 
 struct cr_XmlStruct
-cr_xml_dump(cr_Package *pkg)
+cr_xml_dump(cr_Package *pkg, GError **err)
 {
     struct cr_XmlStruct result;
+    GError *tmp_err = NULL;
+
+    assert(!err || *err == NULL);
 
     if (!pkg) {
         result.primary   = NULL;
@@ -188,9 +193,29 @@ cr_xml_dump(cr_Package *pkg)
         return result;
     }
 
-    result.primary   = cr_xml_dump_primary(pkg);
-    result.filelists = cr_xml_dump_filelists(pkg);
-    result.other     = cr_xml_dump_other(pkg);
+    result.primary = cr_xml_dump_primary(pkg, &tmp_err);
+    if (tmp_err) {
+        g_propagate_error(err, tmp_err);
+        return result;
+    }
+
+    result.filelists = cr_xml_dump_filelists(pkg, &tmp_err);
+    if (tmp_err) {
+        g_propagate_error(err, tmp_err);
+        g_free(result.primary);
+        result.primary = NULL;
+        return result;
+    }
+
+    result.other = cr_xml_dump_other(pkg, &tmp_err);
+    if (tmp_err) {
+        g_propagate_error(err, tmp_err);
+        g_free(result.primary);
+        result.primary = NULL;
+        g_free(result.filelists);
+        result.filelists = NULL;
+        return result;
+    }
 
     return result;
 }

diff --git a/src/xml_dump.h b/src/xml_dump.h
index 1b9a0ca..aa48471 100644 (file)
--- a/src/xml_dump.h
+++ b/src/xml_dump.h
@@ -37,7 +37,7 @@ extern "C" {
  *                           "repodata/rpm.rpm", NULL, 10, NULL);
  *
  * cr_xml_dump_init();
- * xml = cr_xml_dump(pkg);
+ * xml = cr_xml_dump(pkg, NULL);
  * cr_xml_dump_cleanup();
  *
  * cr_package_free(pkg);
@@ -83,27 +83,31 @@ void cr_xml_dump_cleanup();
 
 /** Generate primary xml chunk from cr_Package.
  * @param package       cr_Package
+ * @param err           **GError
  * @return              xml chunk string or NULL on error
  */
-char *cr_xml_dump_primary(cr_Package *package);
+char *cr_xml_dump_primary(cr_Package *package, GError **err);
 
 /** Generate filelists xml chunk from cr_Package.
  * @param package       cr_Package
+ * @param err           **GError
  * @return              xml chunk string or NULL on error
  */
-char *cr_xml_dump_filelists(cr_Package *package);
+char *cr_xml_dump_filelists(cr_Package *package, GError **err);
 
 /** Generate other xml chunk from cr_Package.
  * @param package       cr_Package
+ * @param err           **GError
  * @return              xml chunk string or NULL on error
  */
-char *cr_xml_dump_other(cr_Package *package);
+char *cr_xml_dump_other(cr_Package *package, GError **err);
 
 /** Generate all three xml chunks (primary, filelists, other) from cr_Package.
  * @param package       cr_Package
+ * @param err           **GError
  * @return              cr_XmlStruct
  */
-struct cr_XmlStruct cr_xml_dump(cr_Package *package);
+struct cr_XmlStruct cr_xml_dump(cr_Package *package, GError **err);
 
 /** Prepare string to xml dump.
  * If string is not utf8 it is converted (source encoding is supposed to be

diff --git a/src/xml_dump_filelists.c b/src/xml_dump_filelists.c
index 9150e87..56f409d 100644 (file)
--- a/src/xml_dump_filelists.c
+++ b/src/xml_dump_filelists.c
@@ -23,6 +23,7 @@
 #include <string.h>
 #include <libxml/encoding.h>
 #include <libxml/xmlwriter.h>
+#include "error.h"
 #include "logging.h"
 #include "package.h"
 #include "xml_dump.h"
@@ -75,36 +76,38 @@ cr_xml_dump_filelists_items(xmlNodePtr root, cr_Package *package)
 
 
 char *
-cr_xml_dump_filelists(cr_Package *package)
+cr_xml_dump_filelists(cr_Package *package, GError **err)
 {
+    xmlNodePtr root;
+    char *result;
+
     if (!package)
         return NULL;
 
-    xmlNodePtr root = NULL;
-    root = xmlNewNode(NULL, BAD_CAST "package");
-
 
     // Dump IT!
 
-    cr_xml_dump_filelists_items(root, package);
-
-    char *result;
     xmlBufferPtr buf = xmlBufferCreate();
     if (buf == NULL) {
         g_critical("%s: Error creating the xml buffer", __func__);
+        g_set_error(err, CR_XML_DUMP_FILELISTS_ERROR, CRE_MEMORY,
+                    "Cannot create an xml buffer");
         return NULL;
     }
-    // Seems to be little bit faster than xmlDocDumpFormatMemory
+
+    root = xmlNewNode(NULL, BAD_CAST "package");
+    cr_xml_dump_filelists_items(root, package);
+    // xmlNodeDump seems to be a little bit faster than xmlDocDumpFormatMemory
     xmlNodeDump(buf, NULL, root, FORMAT_LEVEL, FORMAT_XML);
     assert(buf->content);
     result = g_strndup((char *) buf->content, (buf->use+1));
     result[buf->use]     = '\n';
     result[buf->use+1]   = '\0';
-    xmlBufferFree(buf);
 
 
     // Cleanup
 
+    xmlBufferFree(buf);
     xmlFreeNode(root);
 
     return result;

diff --git a/src/xml_dump_other.c b/src/xml_dump_other.c
index 74f41dc..983fe67 100644 (file)
--- a/src/xml_dump_other.c
+++ b/src/xml_dump_other.c
@@ -24,6 +24,7 @@
 #include <libxml/encoding.h>
 #include <libxml/xmlwriter.h>
 #include <libxml/xmlsave.h>
+#include "error.h"
 #include "logging.h"
 #include "package.h"
 #include "xml_dump.h"
@@ -116,38 +117,38 @@ cr_xml_dump_other_items(xmlNodePtr root, cr_Package *package)
 
 
 char *
-cr_xml_dump_other(cr_Package *package)
+cr_xml_dump_other(cr_Package *package, GError **err)
 {
+    xmlNodePtr root;
+    char *result;
+
     if (!package)
         return NULL;
 
-    xmlNodePtr root = NULL;
-    root = xmlNewNode(NULL, BAD_CAST "package");
-
 
     // Dump IT!
 
-    cr_xml_dump_other_items(root, package);
-
-    char *result;
     xmlBufferPtr buf = xmlBufferCreate();
     if (buf == NULL) {
         g_critical("%s: Error creating the xml buffer", __func__);
+        g_set_error(err, CR_XML_DUMP_OTHER_ERROR, CRE_MEMORY,
+                    "Cannot create an xml buffer");
         return NULL;
     }
-    // Seems to be little bit faster than xmlDocDumpFormatMemory
-//    xmlSaveCtxtPtr savebuf = xmlSaveToBuffer(buf, NULL, XML_SAVE_FORMAT|XML_SAVE_NO_DECL);
-//    xmlSaveTree(savebuf, root);
+
+    root = xmlNewNode(NULL, BAD_CAST "package");
+    cr_xml_dump_other_items(root, package);
+    // xmlNodeDump seems to be a little bit faster than xmlDocDumpFormatMemory
     xmlNodeDump(buf, NULL, root, FORMAT_LEVEL, FORMAT_XML);
     assert(buf->content);
     result = g_strndup((char *) buf->content, (buf->use+1));
     result[buf->use]     = '\n';
     result[buf->use+1]   = '\0';
-    xmlBufferFree(buf);
 
 
     // Cleanup
 
+    xmlBufferFree(buf);
     xmlFreeNode(root);
 
     return result;

diff --git a/src/xml_dump_primary.c b/src/xml_dump_primary.c
index 50390e0..3ae229f 100644 (file)
--- a/src/xml_dump_primary.c
+++ b/src/xml_dump_primary.c
@@ -23,6 +23,7 @@
 #include <string.h>
 #include <libxml/encoding.h>
 #include <libxml/xmlwriter.h>
+#include "error.h"
 #include "logging.h"
 #include "package.h"
 #include "xml_dump.h"
@@ -367,36 +368,38 @@ cr_xml_dump_primary_base_items(xmlNodePtr root, cr_Package *package)
 
 
 char *
-cr_xml_dump_primary(cr_Package *package)
+cr_xml_dump_primary(cr_Package *package, GError **err)
 {
+    xmlNodePtr root;
+    char *result;
+
     if (!package)
         return NULL;
 
-    xmlNodePtr root = NULL;
-    root = xmlNewNode(NULL, BAD_CAST "package");
-
 
     // Dump IT!
 
-    cr_xml_dump_primary_base_items(root, package);
-
-    char *result;
     xmlBufferPtr buf = xmlBufferCreate();
     if (buf == NULL) {
         g_critical("%s: Error creating the xml buffer", __func__);
+        g_set_error(err, CR_XML_DUMP_PRIMARY_ERROR, CRE_MEMORY,
+                    "Cannot create an xml buffer");
         return NULL;
     }
-    // Seems to be little bit faster than xmlDocDumpFormatMemory
+
+    root = xmlNewNode(NULL, BAD_CAST "package");
+    cr_xml_dump_primary_base_items(root, package);
+    // xmlNodeDump seems to be a little bit faster than xmlDocDumpFormatMemory
     xmlNodeDump(buf, NULL, root, FORMAT_LEVEL, FORMAT_XML);
     assert(buf->content);
     result = g_strndup((char *) buf->content, (buf->use+1));
     result[buf->use]     = '\n';
     result[buf->use+1]   = '\0';
-    xmlBufferFree(buf);
 
 
     // Cleanup
 
+    xmlBufferFree(buf);
     xmlFreeNode(root);
 
     return result;

diff --git a/tests/testmisc.c b/tests/testmisc.c
index 524c090..cd7414b 100644 (file)
--- a/tests/testmisc.c
+++ b/tests/testmisc.c
@@ -360,47 +360,43 @@ static void test_cr_compute_file_checksum(void)
 {
     char *checksum;
 
-    checksum = cr_compute_file_checksum(EMPTY_FILE, CR_CHECKSUM_MD5);
+    checksum = cr_compute_file_checksum(EMPTY_FILE, CR_CHECKSUM_MD5, NULL);
     g_assert_cmpstr(checksum, ==, "d41d8cd98f00b204e9800998ecf8427e");
     g_free(checksum);
-    checksum = cr_compute_file_checksum(EMPTY_FILE, CR_CHECKSUM_SHA1);
+    checksum = cr_compute_file_checksum(EMPTY_FILE, CR_CHECKSUM_SHA1, NULL);
     g_assert_cmpstr(checksum, ==, "da39a3ee5e6b4b0d3255bfef95601890afd80709");
     g_free(checksum);
-    checksum = cr_compute_file_checksum(EMPTY_FILE, CR_CHECKSUM_SHA256);
+    checksum = cr_compute_file_checksum(EMPTY_FILE, CR_CHECKSUM_SHA256, NULL);
     g_assert_cmpstr(checksum, ==, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
     g_free(checksum);
 
-    checksum = cr_compute_file_checksum(TEXT_FILE, CR_CHECKSUM_MD5);
+    checksum = cr_compute_file_checksum(TEXT_FILE, CR_CHECKSUM_MD5, NULL);
     g_assert_cmpstr(checksum, ==, "d6d4da5c15f8fe7570ce6ab6b3503916");
     g_free(checksum);
-    checksum = cr_compute_file_checksum(TEXT_FILE, CR_CHECKSUM_SHA1);
+    checksum = cr_compute_file_checksum(TEXT_FILE, CR_CHECKSUM_SHA1, NULL);
     g_assert_cmpstr(checksum, ==, "da048ee8fabfbef1b3d6d3f5a4be20029eecec77");
     g_free(checksum);
-    checksum = cr_compute_file_checksum(TEXT_FILE, CR_CHECKSUM_SHA256);
+    checksum = cr_compute_file_checksum(TEXT_FILE, CR_CHECKSUM_SHA256, NULL);
     g_assert_cmpstr(checksum, ==, "2f395bdfa2750978965e4781ddf224c89646c7d7a1569b7ebb023b170f7bd8bb");
     g_free(checksum);
 
-    checksum = cr_compute_file_checksum(BINARY_FILE, CR_CHECKSUM_MD5);
+    checksum = cr_compute_file_checksum(BINARY_FILE, CR_CHECKSUM_MD5, NULL);
     g_assert_cmpstr(checksum, ==, "4f8b033d7a402927a20c9328fc0e0f46");
     g_free(checksum);
-    checksum = cr_compute_file_checksum(BINARY_FILE, CR_CHECKSUM_SHA1);
+    checksum = cr_compute_file_checksum(BINARY_FILE, CR_CHECKSUM_SHA1, NULL);
     g_assert_cmpstr(checksum, ==, "3539fb660a41846352ac4fa9076d168a3c77070b");
     g_free(checksum);
-    checksum = cr_compute_file_checksum(BINARY_FILE, CR_CHECKSUM_SHA256);
+    checksum = cr_compute_file_checksum(BINARY_FILE, CR_CHECKSUM_SHA256, NULL);
     g_assert_cmpstr(checksum, ==, "bf68e32ad78cea8287be0f35b74fa3fecd0eaa91770b48f1a7282b015d6d883e");
     g_free(checksum);
 
     // Corner cases
 
-    checksum = cr_compute_file_checksum(BINARY_FILE, 244);
+    checksum = cr_compute_file_checksum(BINARY_FILE, 244, NULL);
     g_assert(!checksum);
 
-    checksum = cr_compute_file_checksum(NON_EXIST_FILE, CR_CHECKSUM_MD5);
+    checksum = cr_compute_file_checksum(NON_EXIST_FILE, CR_CHECKSUM_MD5, NULL);
     g_assert(!checksum);
-
-    checksum = cr_compute_file_checksum(NULL, CR_CHECKSUM_MD5);
-    g_assert(!checksum);
-
 }
 
 
@@ -507,7 +503,7 @@ static void copyfiletest_test_empty_file(Copyfiletest *copyfiletest, gconstpoint
     ret = cr_copy_file(EMPTY_FILE, copyfiletest->dst_file);
     g_assert_cmpint(ret, ==, CR_COPY_OK);
     g_assert(g_file_test(copyfiletest->dst_file, G_FILE_TEST_EXISTS|G_FILE_TEST_IS_REGULAR));
-    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256);
+    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256, NULL);
     g_assert_cmpstr(checksum, ==, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
     g_free(checksum);
 }
@@ -523,7 +519,7 @@ static void copyfiletest_test_text_file(Copyfiletest *copyfiletest, gconstpointe
     ret = cr_copy_file(TEXT_FILE, copyfiletest->dst_file);
     g_assert_cmpint(ret, ==, CR_COPY_OK);
     g_assert(g_file_test(copyfiletest->dst_file, G_FILE_TEST_EXISTS|G_FILE_TEST_IS_REGULAR));
-    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256);
+    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256, NULL);
     g_assert_cmpstr(checksum, ==, "2f395bdfa2750978965e4781ddf224c89646c7d7a1569b7ebb023b170f7bd8bb");
     g_free(checksum);
 }
@@ -539,7 +535,7 @@ static void copyfiletest_test_binary_file(Copyfiletest *copyfiletest, gconstpoin
     ret = cr_copy_file(BINARY_FILE, copyfiletest->dst_file);
     g_assert_cmpint(ret, ==, CR_COPY_OK);
     g_assert(g_file_test(copyfiletest->dst_file, G_FILE_TEST_EXISTS|G_FILE_TEST_IS_REGULAR));
-    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256);
+    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256, NULL);
     g_assert_cmpstr(checksum, ==, "bf68e32ad78cea8287be0f35b74fa3fecd0eaa91770b48f1a7282b015d6d883e");
     g_free(checksum);
 }
@@ -555,14 +551,14 @@ static void copyfiletest_test_rewrite(Copyfiletest *copyfiletest, gconstpointer
     ret = cr_copy_file(BINARY_FILE, copyfiletest->dst_file);
     g_assert_cmpint(ret, ==, CR_COPY_OK);
     g_assert(g_file_test(copyfiletest->dst_file, G_FILE_TEST_EXISTS|G_FILE_TEST_IS_REGULAR));
-    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256);
+    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256, NULL);
     g_assert_cmpstr(checksum, ==, "bf68e32ad78cea8287be0f35b74fa3fecd0eaa91770b48f1a7282b015d6d883e");
     g_free(checksum);
 
     ret = cr_copy_file(TEXT_FILE, copyfiletest->dst_file);
     g_assert_cmpint(ret, ==, CR_COPY_OK);
     g_assert(g_file_test(copyfiletest->dst_file, G_FILE_TEST_EXISTS|G_FILE_TEST_IS_REGULAR));
-    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256);
+    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256, NULL);
     g_assert_cmpstr(checksum, ==, "2f395bdfa2750978965e4781ddf224c89646c7d7a1569b7ebb023b170f7bd8bb");
     g_free(checksum);
 }
@@ -590,7 +586,7 @@ static void compressfile_test_text_file(Copyfiletest *copyfiletest, gconstpointe
     ret = cr_compress_file(TEXT_FILE, copyfiletest->dst_file, CR_CW_GZ_COMPRESSION);
     g_assert_cmpint(ret, ==, CR_COPY_OK);
     g_assert(g_file_test(copyfiletest->dst_file, G_FILE_TEST_EXISTS|G_FILE_TEST_IS_REGULAR));
-    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256);
+    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256, NULL);
     g_assert_cmpstr(checksum, ==, "8909fde88a5747d800fd2562b0f22945f014aa7df64cf1c15c7933ae54b72ab6");
     g_free(checksum);
 }
@@ -656,7 +652,7 @@ static void test_cr_better_copy_file_local(Copyfiletest *copyfiletest, gconstpoi
     ret = cr_better_copy_file(BINARY_FILE, copyfiletest->dst_file);
     g_assert_cmpint(ret, ==, CR_COPY_OK);
     g_assert(g_file_test(copyfiletest->dst_file, G_FILE_TEST_EXISTS|G_FILE_TEST_IS_REGULAR));
-    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256);
+    checksum = cr_compute_file_checksum(copyfiletest->dst_file, CR_CHECKSUM_SHA256, NULL);
     g_assert_cmpstr(checksum, ==, "bf68e32ad78cea8287be0f35b74fa3fecd0eaa91770b48f1a7282b015d6d883e");
     g_free(checksum);
 }