Add interface functions to JobData

2026-05-06 10:38:54 +02:00
parent 2def836b73
commit dc33404734
6 changed files with 96 additions and 131 deletions
@@ -21,7 +21,7 @@ target_sources(katja PUBLIC FILE_SET all_my_modules TYPE CXX_MODULES FILES
 	katja/database.cpp katja/repository.cpp katja/sbo.cpp)
 include_directories(include ${Boost_INCLUDE_DIR})

-# add_subdirectory(backend)
+add_subdirectory(backend)
 if(KATJA_BUILD_CLI)
 	add_subdirectory(cli)
 endif()
@@ -4,14 +4,13 @@
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 #include "config.h"
-#include <dirent.h>
+#include <filesystem>
 #include <gio/gio.h>
 #include <cstdint>
 #include <stdlib.h>
 #include <iostream>
 #include <zlib.h>
 #include <curl/curl.h>
-#include <sqlite3.h>
 #include "job.h"
 #include "pkgtools.h"
 #include "slackpkg.h"
@@ -158,12 +157,11 @@ void pk_backend_stop_job(JobData *job_data)
    g_free(job_data);
 }

-void pk_backend_search_thread(PkBackendJob *job, GVariant *params, const char *user_data)
+void pk_backend_search_thread(JobData *job_data, GVariant *params, const char *user_data)
 {
-    auto job_data = reinterpret_cast<katja::JobData *>(pk_backend_job_get_user_data(job));
-
    char **vals;
-    PkBitfield filters;
+    // -1 means requesting not installed, 1 - installed, 0 - no filters.
+    guint64 filters;
    g_variant_get(params, "(t^a&s)", &filters, &vals);
    char *search = g_strjoinv("%", vals);

@@ -183,15 +181,15 @@ void pk_backend_search_thread(PkBackendJob *job, GVariant *params, const char *u
                    reinterpret_cast<const char *>(sqlite3_column_text(stmt, 2)));

            if ((info == katja::Info::installed || info == katja::Info::updating)
-                    && !pk_bitfield_contain(filters, PK_FILTER_ENUM_NOT_INSTALLED))
+                    && filters != -1)
            {
-                pk_backend_job_package(job, katja::Info::installed,
+                job_data->package(katja::Info::installed,
                        reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0)),
                        reinterpret_cast<const char *>(sqlite3_column_text(stmt, 1)));
            }
-            else if (info == katja::Info::installing && !pk_bitfield_contain(filters, PK_FILTER_ENUM_INSTALLED))
+            else if (info == katja::Info::installing && filters != 1)
            {
-                pk_backend_job_package(job, katja::Info::available,
+                job_data->package(katja::Info::available,
                        reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0)),
                        reinterpret_cast<const char *>(sqlite3_column_text(stmt, 1)));
            }
@@ -206,13 +204,12 @@ void pk_backend_search_thread(PkBackendJob *job, GVariant *params, const char *u
    g_free(search);
 }

-void pk_backend_search_files(PkBackendJob *job, char **values)
+void pk_backend_search_files(JobData *job_data, char **values)
 {
    char *search;
    char *query;
    sqlite3_stmt *stmt;
    Info ret;
-    auto job_data = static_cast<JobData *>(pk_backend_job_get_user_data(job));

    search = g_strjoinv("%", values);

@@ -228,13 +225,13 @@ void pk_backend_search_files(PkBackendJob *job, char **values)
            ret = is_installed((char*) sqlite3_column_text(stmt, 2));
            if ((ret == Info::installed) || (ret == Info::updating))
            {
-                pk_backend_job_package(job, katja::Info::installed,
+                job_data->package(katja::Info::installed,
                        (char*) sqlite3_column_text(stmt, 0),
                        (char*) sqlite3_column_text(stmt, 1));
            }
            else if (ret == katja::Info::installing)
            {
-                pk_backend_job_package(job, katja::Info::available,
+                job_data->package(katja::Info::available,
                        (char*) sqlite3_column_text(stmt, 0),
                        (char*) sqlite3_column_text(stmt, 1));
            }
@@ -249,7 +246,7 @@ void pk_backend_search_files(PkBackendJob *job, char **values)
    g_free(search);
 }

-void pk_backend_get_details(PkBackendJob *job, char **package_ids)
+void pk_backend_get_details(JobData *job_data, char **package_ids)
 {
    char *homepage = nullptr;
    char** tokens;
@@ -259,11 +256,10 @@ void pk_backend_get_details(PkBackendJob *job, char **package_ids)
    GMatchInfo *match_info;
    GError *err = nullptr;
    sqlite3_stmt *stmt;
-    auto job_data = static_cast<JobData *>(pk_backend_job_get_user_data(job));

    if ((sqlite3_prepare_v2(job_data->db,
                            "SELECT p.desc, p.cat, p.uncompressed FROM pkglist AS p NATURAL JOIN repos AS r "
-                            "WHERE name LIKE @name AND r.repo LIKE @repo AND ext NOT LIKE 'obsolete'",
+                            "WHERE name LIKE @name AND r.repo LIKE @repo",
                            -1,
                            &stmt,
                            nullptr) != SQLITE_OK)) {
@@ -271,9 +267,9 @@ void pk_backend_get_details(PkBackendJob *job, char **package_ids)
        goto out;
    }

-    tokens = pk_package_id_split(package_ids[0]);
-    sqlite3_bind_text(stmt, 1, tokens[PK_PACKAGE_ID_NAME], -1, SQLITE_TRANSIENT);
-    sqlite3_bind_text(stmt, 2, tokens[PK_PACKAGE_ID_DATA], -1, SQLITE_TRANSIENT);
+    tokens = g_strsplit(package_ids[0], ";", 4);
+    sqlite3_bind_text(stmt, 1, tokens[0], -1, SQLITE_TRANSIENT);
+    sqlite3_bind_text(stmt, 2, tokens[3], -1, SQLITE_TRANSIENT);
    g_strfreev(tokens);

    if (sqlite3_step(stmt) != SQLITE_ROW)
@@ -310,15 +306,11 @@ void pk_backend_get_details(PkBackendJob *job, char **package_ids)
    g_regex_unref(expr);

    /* Ready */
-    pk_backend_job_details(job,
-                package_ids[0],
-                nullptr,
-                nullptr,
-                pk_group_enum_from_string((char *) sqlite3_column_text(stmt, 1)),
-                desc->str,
-                homepage,
-                sqlite3_column_int(stmt, 2),
-                G_MAXUINT64);
+    job_data->details(package_ids[0],
+            (char *) sqlite3_column_text(stmt, 1),
+            desc->str,
+            homepage,
+            sqlite3_column_int(stmt, 2));

    g_free(homepage);
    if (desc)
@@ -330,12 +322,10 @@ out:
    sqlite3_finalize(stmt);
 }

-void pk_backend_resolve(PkBackendJob *job, char **packages)
+void pk_backend_resolve(JobData *job_data, char **packages)
 {
    char **val;
    sqlite3_stmt *stmt;
-    PkInfoEnum ret;
-    auto job_data = static_cast<JobData *>(pk_backend_job_get_user_data(job));

    if ((sqlite3_prepare_v2(job_data->db,
                            "SELECT (p1.name || ';' || p1.ver || ';' || p1.arch || ';' || r.repo), p1.summary, "
@@ -352,18 +342,9 @@ void pk_backend_resolve(PkBackendJob *job, char **packages)

            while (sqlite3_step(stmt) == SQLITE_ROW)
            {
-                if ((ret == Info::installed) || (ret == Info::updating))
-                {
-                    pk_backend_job_package(job, katja::Info::installed,
-                            (char*) sqlite3_column_text(stmt, 0),
-                            (char*) sqlite3_column_text(stmt, 1));
-                }
-                else if (ret == katja::Info::installing)
-                {
-                    pk_backend_job_package(job, katja::Info::available,
-                            (char*) sqlite3_column_text(stmt, 0),
-                            (char*) sqlite3_column_text(stmt, 1));
-                }
+                job_data->package(katja::Info::available,
+                        (char *) sqlite3_column_text(stmt, 0),
+                        (char *) sqlite3_column_text(stmt, 1));
            }

            sqlite3_clear_bindings(stmt);
@@ -377,12 +358,11 @@ void pk_backend_resolve(PkBackendJob *job, char **packages)
    }
 }

-void pk_backend_download_packages(PkBackendJob *job, char **package_ids, const char *directory)
+void pk_backend_download_packages(JobData *job_data, char **package_ids, const char *directory)
 {
    char *path, *to_strv[] = {nullptr, nullptr};
    unsigned i;
    sqlite3_stmt *stmt;
-    auto job_data = static_cast<JobData *>(pk_backend_job_get_user_data(job));

    if ((sqlite3_prepare_v2(job_data->db,
                            "SELECT summary, (full_name || '.' || ext) FROM pkglist NATURAL JOIN repos "
@@ -397,22 +377,21 @@ void pk_backend_download_packages(PkBackendJob *job, char **package_ids, const c

    for (i = 0; package_ids[i]; ++i)
    {
-        char **tokens = pk_package_id_split(package_ids[i]);
+        char **tokens = g_strsplit(package_ids[i], ";", 4);

-        sqlite3_bind_text(stmt, 1, tokens[PK_PACKAGE_ID_NAME], -1, SQLITE_TRANSIENT);
-        sqlite3_bind_text(stmt, 2, tokens[PK_PACKAGE_ID_VERSION], -1, SQLITE_TRANSIENT);
-        sqlite3_bind_text(stmt, 3, tokens[PK_PACKAGE_ID_ARCH], -1, SQLITE_TRANSIENT);
-        sqlite3_bind_text(stmt, 4, tokens[PK_PACKAGE_ID_DATA], -1, SQLITE_TRANSIENT);
+        sqlite3_bind_text(stmt, 1, tokens[0], -1, SQLITE_TRANSIENT);
+        sqlite3_bind_text(stmt, 2, tokens[1], -1, SQLITE_TRANSIENT);
+        sqlite3_bind_text(stmt, 3, tokens[2], -1, SQLITE_TRANSIENT);
+        sqlite3_bind_text(stmt, 4, tokens[3], -1, SQLITE_TRANSIENT);
        if (sqlite3_step(stmt) == SQLITE_ROW)
        {
            GSList *repo;
-            if ((repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo)))
+            if ((repo = g_slist_find_custom(repos, tokens[3], cmp_repo)))
            {
-                static_cast<Pkgtools *>(repo->data)->download(job,
-                        directory, tokens[PK_PACKAGE_ID_NAME]);
+                static_cast<Pkgtools *>(repo->data)->download(job_data, directory, tokens[0]);
                path = g_build_filename(directory, (char *) sqlite3_column_text(stmt, 1), nullptr);
                to_strv[0] = path;
-                pk_backend_job_files(job, nullptr, to_strv);
+                job_data->files(to_strv);
                g_free(path);
            }
        }
@@ -425,15 +404,13 @@ out:
    sqlite3_finalize(stmt);
 }

-void pk_backend_install_packages(PkBackendJob *job, char **package_ids)
+void pk_backend_install_packages(JobData *job_data, char **package_ids)
 {
    char *dest_dir_name;
    unsigned i;
    gdouble percent_step;
    GSList *install_list = nullptr, *l;
    sqlite3_stmt *pkglist_stmt = nullptr, *collection_stmt = nullptr;
-    PkInfoEnum ret;
-    auto job_data = static_cast<JobData *>(pk_backend_job_get_user_data(job));

    if ((sqlite3_prepare_v2(job_data->db,
                            "SELECT summary, cat FROM pkglist NATURAL JOIN repos "
@@ -457,11 +434,11 @@ void pk_backend_install_packages(PkBackendJob *job, char **package_ids)

    for (i = 0; package_ids[i]; i++)
    {
-        char **tokens = pk_package_id_split(package_ids[i]);
-        sqlite3_bind_text(pkglist_stmt, 1, tokens[PK_PACKAGE_ID_NAME], -1, SQLITE_TRANSIENT);
-        sqlite3_bind_text(pkglist_stmt, 2, tokens[PK_PACKAGE_ID_VERSION], -1, SQLITE_TRANSIENT);
-        sqlite3_bind_text(pkglist_stmt, 3, tokens[PK_PACKAGE_ID_ARCH], -1, SQLITE_TRANSIENT);
-        sqlite3_bind_text(pkglist_stmt, 4, tokens[PK_PACKAGE_ID_DATA], -1, SQLITE_TRANSIENT);
+        char **tokens = g_strsplit(package_ids[i], ";", 4);
+        sqlite3_bind_text(pkglist_stmt, 1, tokens[0], -1, SQLITE_TRANSIENT);
+        sqlite3_bind_text(pkglist_stmt, 2, tokens[1], -1, SQLITE_TRANSIENT);
+        sqlite3_bind_text(pkglist_stmt, 3, tokens[2], -1, SQLITE_TRANSIENT);
+        sqlite3_bind_text(pkglist_stmt, 4, tokens[3], -1, SQLITE_TRANSIENT);

        if (sqlite3_step(pkglist_stmt) == SQLITE_ROW)
        {
@@ -472,12 +449,12 @@ void pk_backend_install_packages(PkBackendJob *job, char **package_ids)
            }
            else
            {
-                sqlite3_bind_text(collection_stmt, 1, tokens[PK_PACKAGE_ID_NAME], -1, SQLITE_TRANSIENT);
-                sqlite3_bind_text(collection_stmt, 2, tokens[PK_PACKAGE_ID_DATA], -1, SQLITE_TRANSIENT);
+                sqlite3_bind_text(collection_stmt, 1, tokens[0], -1, SQLITE_TRANSIENT);
+                sqlite3_bind_text(collection_stmt, 2, tokens[3], -1, SQLITE_TRANSIENT);

                while (sqlite3_step(collection_stmt) == SQLITE_ROW)
                {
-                    ret = is_installed((char*) sqlite3_column_text(collection_stmt, 2));
+                    katja::Info ret = is_installed((char*) sqlite3_column_text(collection_stmt, 2));
                    if ((ret == Info::installing) || (ret == Info::updating))
                    {
                        install_list = g_slist_append(install_list,
@@ -506,14 +483,13 @@ void pk_backend_install_packages(PkBackendJob *job, char **package_ids)
            char **tokens;
            GSList *repo;

-            pk_backend_job_set_percentage(job, percent_step * i);
-            tokens = pk_package_id_split((char *)(l->data));
-            repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo);
+            job_data->set_percentage(percent_step * i);
+            tokens = g_strsplit((char *)(l->data), ";", 4);
+            repo = g_slist_find_custom(repos, tokens[3], cmp_repo);

            if (repo)
            {
-                static_cast<Pkgtools *>(repo->data)->download(job,
-                        dest_dir_name, tokens[PK_PACKAGE_ID_NAME]);
+                static_cast<Pkgtools *>(repo->data)->download(job_data, dest_dir_name, tokens[0]);
            }
            g_strfreev(tokens);
        }
@@ -525,13 +501,13 @@ void pk_backend_install_packages(PkBackendJob *job, char **package_ids)
            char **tokens;
            GSList *repo;

-            pk_backend_job_set_percentage(job, percent_step * i);
-            tokens = pk_package_id_split((char *)(l->data));
-            repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo);
+            job_data->set_percentage(percent_step * i);
+            tokens = g_strsplit((char *)(l->data), ";", 4);
+            repo = g_slist_find_custom(repos, tokens[3], cmp_repo);

            if (repo)
            {
-                static_cast<Pkgtools *>(repo->data)->install(job, tokens[PK_PACKAGE_ID_NAME]);
+                static_cast<Pkgtools *>(repo->data)->install(job_data, tokens[0]);
            }
            g_strfreev(tokens);
        }
@@ -543,7 +519,7 @@ out:
    sqlite3_finalize(collection_stmt);
 }

-void pk_backend_remove_packages(PkBackendJob *job, char **package_ids)
+void pk_backend_remove_packages(JobData* job_data, char **package_ids)
 {
    char *cmd_line;
    unsigned i;
@@ -556,9 +532,9 @@ void pk_backend_remove_packages(PkBackendJob *job, char **package_ids)
    {
        char **tokens;

-        pk_backend_job_set_percentage(job, percent_step * i);
-        tokens = pk_package_id_split(package_ids[i]);
-        cmd_line = g_strconcat("/sbin/removepkg ", tokens[PK_PACKAGE_ID_NAME], nullptr);
+        job_data->set_percentage(percent_step * i);
+        tokens = g_strsplit(package_ids[i], ";", 4);
+        cmd_line = g_strconcat("/sbin/removepkg ", tokens[0], nullptr);

        /* Pkgtools return always 0 */
        g_spawn_command_line_sync(cmd_line, nullptr, nullptr, nullptr, &err);
@@ -574,11 +550,11 @@ void pk_backend_remove_packages(PkBackendJob *job, char **package_ids)
            return;
        }

-        pk_backend_job_set_percentage(job, 100);
+        job_data->set_percentage(100);
    }
 }

-void pk_backend_get_updates(PkBackendJob *job)
+void pk_backend_get_updates(JobData *job_data)
 {
    char *pkg_id, *full_name, *desc;
    const char *pkg_metadata_filename;
@@ -587,7 +563,6 @@ void pk_backend_get_updates(PkBackendJob *job)
    GFileInfo *pkg_metadata_file_info;
    GError *err = nullptr;
    sqlite3_stmt *stmt;
-    auto job_data = static_cast<JobData *>(pk_backend_job_get_user_data(job));

    if ((sqlite3_prepare_v2(job_data->db,
                            "SELECT p1.full_name, p1.name, p1.ver, p1.arch, r.repo, p1.summary, p1.ext "
@@ -636,13 +611,15 @@ void pk_backend_get_updates(PkBackendJob *job)

            if (g_strcmp0(pkg_metadata_filename, full_name))
            { /* Update available */
-                pkg_id = pk_package_id_build((char *) sqlite3_column_text(stmt, 1),
+                pkg_id = g_strjoin(";",
+                        (char *) sqlite3_column_text(stmt, 1),
                        (char *) sqlite3_column_text(stmt, 2),
                        (char *) sqlite3_column_text(stmt, 3),
-                        (char *) sqlite3_column_text(stmt, 4));
+                        (char *) sqlite3_column_text(stmt, 4),
+                        nullptr);
                desc = g_strdup((char *) sqlite3_column_text(stmt, 5));

-                pk_backend_job_package(job, katja::Info::updating, pkg_id, desc);
+                job_data->package(katja::Info::updating, pkg_id, desc);

                g_free(desc);
                g_free(pkg_id);
@@ -671,19 +648,13 @@ void pk_backend_update_packages(JobData *job_data, char **package_ids)
    dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", nullptr);
    for (i = 0; package_ids[i]; i++)
    {
-        char **tokens = pk_package_id_split(package_ids[i]);
+        char **tokens = g_strsplit(package_ids[i], ";", 4);
+        GSList *repo = g_slist_find_custom(repos, tokens[3], cmp_repo);

-        if (g_strcmp0(tokens[PK_PACKAGE_ID_DATA], "obsolete"))
+        if (repo)
        {
-            GSList *repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo);
-
-            if (repo)
-            {
-                static_cast<Pkgtools *>(repo->data)->download(job_data,
-                        dest_dir_name, tokens[PK_PACKAGE_ID_NAME]);
-            }
+            static_cast<Pkgtools *>(repo->data)->download(job_data, dest_dir_name, tokens[0]);
        }
-
        g_strfreev(tokens);
    }
    g_free(dest_dir_name);
@@ -691,25 +662,12 @@ void pk_backend_update_packages(JobData *job_data, char **package_ids)
    /* Install the packages */
    for (i = 0; package_ids[i]; i++)
    {
-        char **tokens = pk_package_id_split(package_ids[i]);
+        char **tokens = g_strsplit(package_ids[i], ";", 4);
+        GSList *repo = g_slist_find_custom(repos, tokens[3], cmp_repo);

-        if (g_strcmp0(tokens[PK_PACKAGE_ID_DATA], "obsolete"))
+        if (repo)
        {
-            GSList *repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo);
-
-            if (repo)
-            {
-                static_cast<Pkgtools *>(repo->data)->install(job_data,
-                        tokens[PK_PACKAGE_ID_NAME]);
-            }
-        }
-        else
-        {
-            /* Remove obsolete package
-             * TODO: Removing should be an independent operation (not during installing updates) */
-            cmd_line = g_strconcat("/sbin/removepkg ", tokens[PK_PACKAGE_ID_NAME], nullptr);
-            g_spawn_command_line_sync(cmd_line, nullptr, nullptr, nullptr, nullptr);
-            g_free(cmd_line);
+            static_cast<Pkgtools *>(repo->data)->install(job_data, tokens[0]);
        }
        g_strfreev(tokens);
    }
@@ -804,7 +762,7 @@ out:
    }
    g_free(path);

-    pk_directory_remove_contents(tmp_dir_name);
+    std::filesystem::remove_all(tmp_dir_name);
    g_rmdir(tmp_dir_name);
    g_free(tmp_dir_name);
 }
@@ -12,18 +12,18 @@ void pk_backend_initialize(GKeyFile *conf);
 void pk_backend_destroy();

 katja::JobData *pk_backend_start_job();
-void pk_backend_stop_job(katja::JobData *job_data)
+void pk_backend_stop_job(katja::JobData *job_data);

-void pk_backend_search_thread(PkBackendJob *job, GVariant *params, const char *user_data);
-void pk_backend_search_files(PkBackendJob *job, char **values);
+void pk_backend_search_thread(katja::JobData *job_data, GVariant *params, const char *user_data);
+void pk_backend_search_files(katja::JobData *job_data, char **values);

-void pk_backend_get_details(PkBackendJob *job, char **package_ids);
-void pk_backend_resolve(PkBackendJob *job, char **packages);
+void pk_backend_get_details(katja::JobData *job_data, char **package_ids);
+void pk_backend_resolve(katja::JobData *job_data, char **packages);

-void pk_backend_download_packages(PkBackendJob *job, char **package_ids, const char *directory);
-void pk_backend_install_packages(PkBackendJob *job, char **package_ids);
-void pk_backend_remove_packages(PkBackendJob *job, char **package_ids);
+void pk_backend_download_packages(katja::JobData *job_data, char **package_ids, const char *directory);
+void pk_backend_install_packages(katja::JobData *job_data, char **package_ids);
+void pk_backend_remove_packages(katja::JobData *job_data, char **package_ids);

-void pk_backend_get_updates(PkBackendJob *job);
+void pk_backend_get_updates(katja::JobData *job_data);
 void pk_backend_update_packages(katja::JobData *job_data, char **package_ids);
 void pk_backend_refresh_cache(katja::JobData *job, bool force);
@@ -20,7 +20,7 @@ namespace katja
 *
 * Returns: %TRUE on success, %FALSE otherwise.
 **/
-bool Pkgtools::download(JobData *job_data, char *dest_dir_name, char *pkg_name) noexcept
+bool Pkgtools::download(JobData *job_data, const char *dest_dir_name, char *pkg_name) noexcept
 {
    char *dest_filename, *source_url;
    bool ret = false;
@@ -21,7 +21,7 @@ public:

    virtual ~Pkgtools() noexcept;

-    bool download(JobData *job_data, char *dest_dir_name, char *pkg_name) noexcept;
+    bool download(JobData *job_data, const char *dest_dir_name, char *pkg_name) noexcept;
    void install(JobData *job_data, char *pkg_name) noexcept;

    virtual GSList *collect_cache_info (const char *tmpl) noexcept = 0;
@@ -6,15 +6,10 @@
 #pragma once

 #include <curl/curl.h>
+#include <sqlite3.h>

 namespace katja
 {
-struct JobData
-{
-    sqlite3 *db;
-    CURL *curl;
-};
-
 enum class Info
 {
    // Error.
@@ -29,6 +24,18 @@ enum class Info
    available
 };

+struct JobData
+{
+    sqlite3 *db;
+    CURL *curl;
+
+    virtual void package(Info info, const char *package_id, const char *summary) = 0;
+    virtual void files(char **) = 0;
+    virtual void details(char *package_id,
+            const char *group, const char *description, const char *homepage, int uncompressed) = 0;
+    virtual void set_percentage(double) = 0;
+};
+
 CURLcode get_file(CURL **curl, char *source_url, char *dest);

 char **split_package_name(const char *pkg_filename);