From 2def836b73185774d3ea6d88dc77c3246daa0f3c Mon Sep 17 00:00:00 2001 From: Eugen Wissner Date: Mon, 4 May 2026 15:37:47 +0200 Subject: [PATCH] Remove dropline backend support --- CMakeLists.txt | 1 + backend/CMakeLists.txt | 4 +- backend/dl.cc | 293 ---------- backend/dl.h | 28 - backend/job.cc | 1220 +++++++++++++++++++--------------------- backend/job.h | 14 +- backend/pkgtools.cc | 164 +++--- backend/pkgtools.h | 27 +- backend/slackpkg.cc | 45 +- backend/slackpkg.h | 5 +- backend/utils.cc | 276 +++++---- backend/utils.h | 16 +- 12 files changed, 829 insertions(+), 1264 deletions(-) delete mode 100644 backend/dl.cc delete mode 100644 backend/dl.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 04d8af6..3c6eede 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,6 +6,7 @@ cmake_minimum_required(VERSION 4.0.0) project(Katja LANGUAGES CXX) include(CTest) +include(GNUInstallDirs) option(KATJA_BUILD_CLI "Build command line interface" ON) diff --git a/backend/CMakeLists.txt b/backend/CMakeLists.txt index 05b46e9..96742e8 100644 --- a/backend/CMakeLists.txt +++ b/backend/CMakeLists.txt @@ -7,8 +7,8 @@ pkg_check_modules(deps REQUIRED IMPORTED_TARGET glib-2.0 gio-2.0) add_library(backend) target_sources(backend - INTERFACE job.h utils.h pkgtools.h slackpkg.h dl.h - PRIVATE job.cc utils.cc pkgtools.cc slackpkg.cc dl.cc + INTERFACE job.h utils.h pkgtools.h slackpkg.h + PRIVATE job.cc utils.cc pkgtools.cc slackpkg.cc ) configure_file(config.h.in ${CMAKE_BINARY_DIR}/generated/config.h) diff --git a/backend/dl.cc b/backend/dl.cc deleted file mode 100644 index fc0fda6..0000000 --- a/backend/dl.cc +++ /dev/null @@ -1,293 +0,0 @@ -/* - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at https://mozilla.org/MPL/2.0/. - */ -#include -#include -#include -#include "dl.h" -#include "utils.h" - -namespace katja -{ -/** - * katja::Dl::collect_cache_info: - * @tmpl: temporary directory for downloading the files. - * - * Download files needed to get the information like the list of packages - * in available repositories, updates, package descriptions and so on. - * - * Returns: List of files needed for building the cache. - **/ -GSList * -Dl::collect_cache_info (const char *tmpl) noexcept -{ - CURL *curl = nullptr; - GSList *file_list = nullptr; - GFile *tmp_dir, *repo_tmp_dir; - - /* Create the temporary directory for the repository */ - tmp_dir = g_file_new_for_path(tmpl); - repo_tmp_dir = g_file_get_child(tmp_dir, this->get_name ()); - g_file_make_directory(repo_tmp_dir, nullptr, nullptr); - - /* There is no ChangeLog yet to check if there are updates or not. Just mark the index file for download */ - auto source_dest = static_cast (g_malloc_n(3, sizeof(char *))); - source_dest[0] = g_strdup(this->index_file); - source_dest[1] = g_build_filename(tmpl, - this->get_name (), - "IndexFile", - nullptr); - source_dest[2] = nullptr; - /* Check if the remote file can be found */ - if (get_file(&curl, source_dest[0], nullptr)) - { - g_strfreev(source_dest); - } - else - { - file_list = g_slist_append(file_list, source_dest); - } - g_object_unref(repo_tmp_dir); - g_object_unref(tmp_dir); - - if (curl) - { - curl_easy_cleanup(curl); - } - return file_list; -} - -/** - * katja::Dl::generate_cache: - * @job_data: A #JobData. - * @tmpl: temporary directory for downloading the files. - * - * Download files needed to get the information like the list of packages - * in available repositories, updates, package descriptions and so on. - * - * Returns: List of files needed for building the cache. - **/ -void -Dl::generate_cache(JobData *job_data, const char *tmpl) noexcept -{ - char **line_tokens, **pkg_tokens, *line, *collection_name = nullptr, *list_filename; - bool skip = false; - GFile *list_file; - GFileInputStream *fin; - GDataInputStream *data_in = nullptr; - sqlite3_stmt *stmt = nullptr; - - /* Check if the temporary directory for this repository exists. If so the file metadata have to be generated */ - list_filename = g_build_filename(tmpl, - this->get_name (), - "IndexFile", - nullptr); - list_file = g_file_new_for_path(list_filename); - if (!(fin = g_file_read(list_file, nullptr, nullptr))) - { - goto out; - } - data_in = g_data_input_stream_new(G_INPUT_STREAM(fin)); - - /* Remove the old entries from this repository */ - if (sqlite3_prepare_v2(job_data->db, - "DELETE FROM repos WHERE repo LIKE @repo", - -1, - &stmt, - nullptr) == SQLITE_OK) { - sqlite3_bind_text(stmt, 1, this->get_name (), -1, SQLITE_TRANSIENT); - sqlite3_step(stmt); - sqlite3_finalize(stmt); - } - if (sqlite3_prepare_v2(job_data->db, - "INSERT INTO repos (repo_order, repo) VALUES (@repo_order, @repo)", - -1, - &stmt, - nullptr) != SQLITE_OK) - { - goto out; - } - sqlite3_bind_int(stmt, 1, this->get_order ()); - sqlite3_bind_text(stmt, 2, this->get_name (), -1, SQLITE_TRANSIENT); - sqlite3_step(stmt); - if (sqlite3_finalize(stmt) != SQLITE_OK) - { - goto out; - } - - /* Insert new records */ - if ((sqlite3_prepare_v2(job_data->db, - "INSERT INTO pkglist (full_name, name, ver, arch, " - "summary, desc, compressed, uncompressed, cat, repo_order, ext) " - "VALUES (@full_name, @name, @ver, @arch, @summary, " - "@desc, @compressed, @uncompressed, @cat, @repo_order, @ext)", - -1, - &stmt, - nullptr) != SQLITE_OK)) - { - goto out; - } - sqlite3_exec(job_data->db, "BEGIN TRANSACTION", nullptr, nullptr, nullptr); - - while ((line = g_data_input_stream_read_line(data_in, nullptr, nullptr, nullptr))) - { - line_tokens = g_strsplit(line, ":", 0); - if ((g_strv_length(line_tokens) > 6) - && !this->is_blacklisted (line_tokens[0])) - { - pkg_tokens = split_package_name(line_tokens[0]); - - /* If the split_package_name doesn't return a full name and an - * extension, it is a collection. We save its name in this case */ - if (pkg_tokens[3]) - { - sqlite3_bind_text(stmt, 1, pkg_tokens[3], -1, SQLITE_TRANSIENT); - sqlite3_bind_text(stmt, 9, "desktop-gnome", -1, SQLITE_STATIC); - if (g_strcmp0(line_tokens[1], "obsolete")) - { - sqlite3_bind_text(stmt, 11, pkg_tokens[4], -1, SQLITE_TRANSIENT); - } - else - { - sqlite3_bind_text(stmt, 11, "obsolete", -1, SQLITE_STATIC); - } - } - else if (!collection_name) - { - collection_name = g_strdup(pkg_tokens[0]); - sqlite3_bind_text(stmt, 1, line_tokens[0], -1, SQLITE_TRANSIENT); - sqlite3_bind_text(stmt, 9, "collections", -1, SQLITE_STATIC); - sqlite3_bind_null(stmt, 11); - } - else - { - skip = true; /* Skip other candidates for collections */ - } - if (skip) - { - skip = false; - } - else - { - sqlite3_bind_text(stmt, 2, pkg_tokens[0], -1, SQLITE_TRANSIENT); - sqlite3_bind_text(stmt, 3, pkg_tokens[1], -1, SQLITE_TRANSIENT); - sqlite3_bind_text(stmt, 4, pkg_tokens[2], -1, SQLITE_TRANSIENT); - sqlite3_bind_text(stmt, 5, line_tokens[2], -1, SQLITE_TRANSIENT); - sqlite3_bind_text(stmt, 6, line_tokens[2], -1, SQLITE_TRANSIENT); - sqlite3_bind_int(stmt, 7, atoi(line_tokens[5])); - sqlite3_bind_int(stmt, 8, atoi(line_tokens[5])); - sqlite3_bind_int(stmt, 10, this->get_order ()); - - sqlite3_step(stmt); - sqlite3_clear_bindings(stmt); - sqlite3_reset(stmt); - } - g_strfreev(pkg_tokens); - } - g_strfreev(line_tokens); - g_free(line); - } - - /* Create a collection entry */ - if (collection_name && g_seekable_seek(G_SEEKABLE(data_in), 0, G_SEEK_SET, nullptr, nullptr) - && (sqlite3_prepare_v2(job_data->db, - "INSERT INTO collections (name, repo_order, collection_pkg) " - "VALUES (@name, @repo_order, @collection_pkg)", - -1, - &stmt, - nullptr) == SQLITE_OK)) - { - while ((line = g_data_input_stream_read_line(data_in, nullptr, nullptr, nullptr))) - { - line_tokens = g_strsplit(line, ":", 0); - if ((g_strv_length(line_tokens) > 6) - && !this->is_blacklisted (line_tokens[0])) - { - pkg_tokens = split_package_name(line_tokens[0]); - - /* If not a collection itself */ - if (pkg_tokens[3]) /* Save this package as a part of the collection */ - { - sqlite3_bind_text(stmt, 1, collection_name, -1, SQLITE_TRANSIENT); - sqlite3_bind_int(stmt, 2, this->get_order ()); - sqlite3_bind_text(stmt, 3, pkg_tokens[0], -1, SQLITE_TRANSIENT); - sqlite3_step(stmt); - sqlite3_clear_bindings(stmt); - sqlite3_reset(stmt); - } - g_strfreev(pkg_tokens); - } - g_strfreev(line_tokens); - g_free(line); - } - sqlite3_finalize(stmt); - } - g_free(collection_name); - - sqlite3_exec(job_data->db, "END TRANSACTION", nullptr, nullptr, nullptr); - -out: - if (data_in) - { - g_object_unref(data_in); - } - if (fin) - { - g_object_unref(fin); - } - g_object_unref(list_file); - g_free(list_filename); -} - -Dl::~Dl () noexcept -{ - if (this->blacklist) - { - g_regex_unref (this->blacklist); - } - - g_free (this->name); - g_free (this->mirror); - g_free (this->index_file); -} - -/** - * katja::Dl::Dl: - * @name: Repository name. - * @mirror: Repository mirror. - * @order: Repository order. - * @blacklist: Repository blacklist. - * @index_file: The index file URL. - * - * Constructor. - * - * Return value: New #katja::Dl. - **/ -Dl::Dl (const char *name, const char *mirror, - std::uint8_t order, const char *blacklist, char *index_file) noexcept -{ - GRegex *regex; - - if (blacklist) - { - regex = static_cast (g_regex_new (blacklist, - G_REGEX_OPTIMIZE, static_cast (0), nullptr)); - } - else - { - regex = nullptr; - } - - this->name = g_strdup (name); - this->mirror = g_strdup (mirror); - - this->order = order; - - this->blacklist = regex; - - this->index_file = index_file; -} - -} diff --git a/backend/dl.h b/backend/dl.h deleted file mode 100644 index 260acc3..0000000 --- a/backend/dl.h +++ /dev/null @@ -1,28 +0,0 @@ -/* - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at https://mozilla.org/MPL/2.0/. - */ -#pragma once - -#include -#include "pkgtools.h" -#include "utils.h" - -namespace katja -{ -class Dl final : public Pkgtools -{ -public: - Dl (const char *name, const char *mirror, - std::uint8_t order, const char *blacklist, char *index_file) noexcept; - ~Dl () noexcept; - - GSList *collect_cache_info (const char *tmpl) noexcept; - void generate_cache (JobData *job_data, const char *tmpl) noexcept; - -private: - char *index_file; -}; - -} diff --git a/backend/job.cc b/backend/job.cc index a39c2ab..372d3e1 100644 --- a/backend/job.cc +++ b/backend/job.cc @@ -13,10 +13,8 @@ #include #include #include "job.h" -#include "dl.h" #include "pkgtools.h" #include "slackpkg.h" -#include "utils.h" using namespace katja; @@ -24,567 +22,533 @@ static GSList *repos = nullptr; void pk_backend_initialize(GKeyFile *conf) { - char *path, **groups; - int ret; - gushort i; - gsize groups_len; - GFile *conf_file; - GFileInfo *file_info; - GKeyFile *key_conf; - GError *err = nullptr; - void *repo = nullptr; - sqlite3 *db; - sqlite3_stmt *stmt; + char *path, **groups; + int ret; + gushort i; + gsize groups_len; + GFile *conf_file; + GFileInfo *file_info; + GKeyFile *key_conf; + GError *err = nullptr; + void *repo = nullptr; + sqlite3 *db; + sqlite3_stmt *stmt; - g_debug("backend: initialize"); - curl_global_init(CURL_GLOBAL_DEFAULT); + g_debug("backend: initialize"); + curl_global_init(CURL_GLOBAL_DEFAULT); - /* Open the database. We will need it to save the time the configuration file was last modified. */ - path = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", nullptr); - if (sqlite3_open(path, &db) != SQLITE_OK) - { - g_error("%s: %s", path, sqlite3_errmsg(db)); - } - g_free(path); + /* Open the database. We will need it to save the time the configuration file was last modified. */ + path = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", nullptr); + if (sqlite3_open(path, &db) != SQLITE_OK) + { + g_error("%s: %s", path, sqlite3_errmsg(db)); + } + g_free(path); - /* Read the configuration file */ - key_conf = g_key_file_new(); - path = g_build_filename(SYSCONFDIR, "PackageKit", "Slackware.conf", nullptr); - g_key_file_load_from_file(key_conf, path, G_KEY_FILE_NONE, &err); - if (err) - { - g_error("%s: %s", path, err->message); - g_error_free(err); - } + /* Read the configuration file */ + key_conf = g_key_file_new(); + path = g_build_filename(SYSCONFDIR, "PackageKit", "Slackware.conf", nullptr); + g_key_file_load_from_file(key_conf, path, G_KEY_FILE_NONE, &err); + if (err) + { + g_error("%s: %s", path, err->message); + g_error_free(err); + } - conf_file = g_file_new_for_path(path); - if (!(file_info = g_file_query_info(conf_file, - "time::modified-usec", - G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, - nullptr, - &err))) - { - g_error("%s", err->message); - g_error_free(err); - } + conf_file = g_file_new_for_path(path); + if (!(file_info = g_file_query_info(conf_file, + "time::modified-usec", + G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, + nullptr, + &err))) + { + g_error("%s", err->message); + g_error_free(err); + } - if ((ret = sqlite3_prepare_v2(db, - "UPDATE cache_info SET value = ? WHERE key LIKE 'last_modification'", - -1, - &stmt, - nullptr)) == SQLITE_OK) { - ret = sqlite3_bind_int(stmt, 1, g_file_info_get_attribute_uint32(file_info, "time::modified-usec")); - if (ret == SQLITE_OK) - { - ret = sqlite3_step(stmt); - } - sqlite3_finalize(stmt); - } - if ((ret != SQLITE_OK) && (ret != SQLITE_DONE)) - { - g_error("%s: %s", path, sqlite3_errstr(ret)); - } - else if (!sqlite3_changes(db)) - { - g_error("Failed to update database: %s", path); - } + if ((ret = sqlite3_prepare_v2(db, + "UPDATE cache_info SET value = ? WHERE key LIKE 'last_modification'", + -1, + &stmt, + nullptr)) == SQLITE_OK) { + ret = sqlite3_bind_int(stmt, 1, g_file_info_get_attribute_uint32(file_info, "time::modified-usec")); + if (ret == SQLITE_OK) + { + ret = sqlite3_step(stmt); + } + sqlite3_finalize(stmt); + } + if ((ret != SQLITE_OK) && (ret != SQLITE_DONE)) + { + g_error("%s: %s", path, sqlite3_errstr(ret)); + } + else if (!sqlite3_changes(db)) + { + g_error("Failed to update database: %s", path); + } - g_object_unref(file_info); - g_object_unref(conf_file); - sqlite3_close_v2(db); - g_free(path); + g_object_unref(file_info); + g_object_unref(conf_file); + sqlite3_close_v2(db); + g_free(path); - /* Initialize an object for each well-formed repository */ - groups = g_key_file_get_groups(key_conf, &groups_len); - for (i = 0; i < groups_len; i++) - { - char *blacklist = g_key_file_get_string(key_conf, groups[i], "Blacklist", nullptr); - char *mirror = g_key_file_get_string(key_conf, groups[i], "Mirror", nullptr); + /* Initialize an object for each well-formed repository */ + groups = g_key_file_get_groups(key_conf, &groups_len); + for (i = 0; i < groups_len; i++) + { + char *blacklist = g_key_file_get_string(key_conf, groups[i], "Blacklist", nullptr); + char *mirror = g_key_file_get_string(key_conf, groups[i], "Mirror", nullptr); - if (g_key_file_has_key(key_conf, groups[i], "Priority", nullptr)) - { - repo = new Slackpkg (groups[i], mirror, i + 1, blacklist, - g_key_file_get_string_list(key_conf, groups[i], "Priority", nullptr, nullptr)); - } - else if (g_key_file_has_key(key_conf, groups[i], "IndexFile", nullptr)) - { - repo = new Dl (groups[i], mirror, i + 1, blacklist, - g_key_file_get_string(key_conf, groups[i], "IndexFile", nullptr)); - } + if (g_key_file_has_key(key_conf, groups[i], "Priority", nullptr)) + { + repo = new Slackpkg(groups[i], mirror, i + 1, blacklist, + g_key_file_get_string_list(key_conf, groups[i], "Priority", nullptr, nullptr)); + repos = g_slist_append(repos, repo); + } + g_free(mirror); + g_free(blacklist); + } + g_free(groups); - if (repo) - { - repos = g_slist_append(repos, repo); - } - else - { - g_free(groups[i]); - } - g_free(mirror); - g_free(blacklist); - } - g_free(groups); - - g_key_file_free(key_conf); + g_key_file_free(key_conf); } void pk_backend_destroy() { - g_debug("backend: destroy"); + g_debug("backend: destroy"); - for (GSList *l = repos; l; l = g_slist_next (l)) - { - delete static_cast (l->data); - } + for (GSList *l = repos; l; l = g_slist_next(l)) + { + delete static_cast(l->data); + } - g_slist_free (repos); - curl_global_cleanup (); + g_slist_free(repos); + curl_global_cleanup(); } -void pk_backend_start_job(PkBackendJob *job) +JobData *pk_backend_start_job() { - char *db_filename = nullptr; - JobData *job_data = g_new0(JobData, 1); + char *db_filename = nullptr; + JobData *job_data = g_new0(JobData, 1); - db_filename = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", nullptr); - if (sqlite3_open(db_filename, &job_data->db) == SQLITE_OK) { /* Some SQLite settings */ - sqlite3_exec(job_data->db, "PRAGMA foreign_keys = ON", nullptr, nullptr, nullptr); - } - else - { + db_filename = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", nullptr); + if (sqlite3_open(db_filename, &job_data->db) == SQLITE_OK) { /* Some SQLite settings */ + sqlite3_exec(job_data->db, "PRAGMA foreign_keys = ON", nullptr, nullptr, nullptr); + } + else + { std::cerr << db_filename << ": " << sqlite3_errmsg(job_data->db) << std::endl; - goto out; - } - - pk_backend_job_set_user_data(job, job_data); + goto out; + } out: - g_free(db_filename); + g_free(db_filename); + + return job_data; } -void pk_backend_stop_job(PkBackendJob *job) +void pk_backend_stop_job(JobData *job_data) { - auto job_data = static_cast (pk_backend_job_get_user_data(job)); + if (job_data->curl) + { + curl_easy_cleanup(job_data->curl); + } - if (job_data->curl) - { - curl_easy_cleanup(job_data->curl); - } - - sqlite3_close(job_data->db); - g_free(job_data); - pk_backend_job_set_user_data(job, nullptr); + sqlite3_close(job_data->db); + g_free(job_data); } -static void -pk_backend_search_thread (PkBackendJob *job, GVariant *params, void *user_data) +void pk_backend_search_thread(PkBackendJob *job, GVariant *params, const char *user_data) { - auto job_data = reinterpret_cast (pk_backend_job_get_user_data (job)); + auto job_data = reinterpret_cast(pk_backend_job_get_user_data(job)); - char **vals; - PkBitfield filters; - g_variant_get (params, "(t^a&s)", &filters, &vals); - char *search = g_strjoinv ("%", vals); + char **vals; + PkBitfield filters; + g_variant_get(params, "(t^a&s)", &filters, &vals); + char *search = g_strjoinv("%", vals); const char *generate_query = "SELECT (p1.name || ';' || p1.ver || ';' || p1.arch || ';' || r.repo), p1.summary, " - "p1.full_name FROM pkglist AS p1 NATURAL JOIN repos AS r " - "WHERE p1.%s LIKE '%%%q%%' AND p1.ext NOT LIKE 'obsolete' AND p1.repo_order = " - "(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)"; - char *query = sqlite3_mprintf (generate_query, user_data, search); + "p1.full_name FROM pkglist AS p1 NATURAL JOIN repos AS r " + "WHERE p1.%s LIKE '%%%q%%' AND p1.ext NOT LIKE 'obsolete' AND p1.repo_order = " + "(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)"; + char *query = sqlite3_mprintf(generate_query, user_data, search); - sqlite3_stmt *stmt; - if ((sqlite3_prepare_v2 (job_data->db, query, -1, &stmt, nullptr) == SQLITE_OK)) - { - /* Now we're ready to output all packages */ - while (sqlite3_step (stmt) == SQLITE_ROW) - { - katja::Info info = katja::is_installed ( - reinterpret_cast (sqlite3_column_text (stmt, 2))); + sqlite3_stmt *stmt; + if ((sqlite3_prepare_v2(job_data->db, query, -1, &stmt, nullptr) == SQLITE_OK)) + { + /* Now we're ready to output all packages */ + while (sqlite3_step(stmt) == SQLITE_ROW) + { + katja::Info info = katja::is_installed( + reinterpret_cast(sqlite3_column_text(stmt, 2))); - if ((info == katja::Info::installed || info == katja::Info::updating) - && !pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) - { - pk_backend_job_package (job, katja::Info::installed, - reinterpret_cast (sqlite3_column_text (stmt, 0)), - reinterpret_cast (sqlite3_column_text (stmt, 1))); - } - else if (info == katja::Info::installing && !pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) - { - pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE, - reinterpret_cast (sqlite3_column_text (stmt, 0)), - reinterpret_cast (sqlite3_column_text (stmt, 1))); - } - } - sqlite3_finalize (stmt); - } - else - { + if ((info == katja::Info::installed || info == katja::Info::updating) + && !pk_bitfield_contain(filters, PK_FILTER_ENUM_NOT_INSTALLED)) + { + pk_backend_job_package(job, katja::Info::installed, + reinterpret_cast(sqlite3_column_text(stmt, 0)), + reinterpret_cast(sqlite3_column_text(stmt, 1))); + } + else if (info == katja::Info::installing && !pk_bitfield_contain(filters, PK_FILTER_ENUM_INSTALLED)) + { + pk_backend_job_package(job, katja::Info::available, + reinterpret_cast(sqlite3_column_text(stmt, 0)), + reinterpret_cast(sqlite3_column_text(stmt, 1))); + } + } + sqlite3_finalize(stmt); + } + else + { std::cerr << sqlite3_errmsg(job_data->db) << std::endl; - } - sqlite3_free (query); - g_free (search); -} - -void pk_backend_search_names(PkBackendJob *job, char **values) -{ - pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "name", nullptr); -} - -void pk_backend_search_details(PkBackendJob *job, char **values) -{ - pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "desc", nullptr); -} - -void pk_backend_search_groups(PkBackendJob *job, char **values) -{ - pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "cat", nullptr); + } + sqlite3_free(query); + g_free(search); } void pk_backend_search_files(PkBackendJob *job, char **values) { - char *search; - char *query; - sqlite3_stmt *stmt; - Info ret; - auto job_data = static_cast (pk_backend_job_get_user_data(job)); + char *search; + char *query; + sqlite3_stmt *stmt; + Info ret; + auto job_data = static_cast(pk_backend_job_get_user_data(job)); - search = g_strjoinv("%", values); + search = g_strjoinv("%", values); - query = sqlite3_mprintf("SELECT (p.name || ';' || p.ver || ';' || p.arch || ';' || r.repo), p.summary, " - "p.full_name FROM filelist AS f NATURAL JOIN pkglist AS p NATURAL JOIN repos AS r " - "WHERE f.filename LIKE '%%%q%%' GROUP BY f.full_name", search); + query = sqlite3_mprintf("SELECT (p.name || ';' || p.ver || ';' || p.arch || ';' || r.repo), p.summary, " + "p.full_name FROM filelist AS f NATURAL JOIN pkglist AS p NATURAL JOIN repos AS r " + "WHERE f.filename LIKE '%%%q%%' GROUP BY f.full_name", search); - if ((sqlite3_prepare_v2(job_data->db, query, -1, &stmt, nullptr) == SQLITE_OK)) - { - /* Now we're ready to output all packages */ - while (sqlite3_step(stmt) == SQLITE_ROW) - { - ret = is_installed((char*) sqlite3_column_text(stmt, 2)); - if ((ret == Info::installed) || (ret == Info::updating)) - { - pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED, - (char*) sqlite3_column_text(stmt, 0), - (char*) sqlite3_column_text(stmt, 1)); - } - else if (ret == PK_INFO_ENUM_INSTALLING) - { - pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE, - (char*) sqlite3_column_text(stmt, 0), - (char*) sqlite3_column_text(stmt, 1)); - } - } - sqlite3_finalize(stmt); - } - else - { + if ((sqlite3_prepare_v2(job_data->db, query, -1, &stmt, nullptr) == SQLITE_OK)) + { + /* Now we're ready to output all packages */ + while (sqlite3_step(stmt) == SQLITE_ROW) + { + ret = is_installed((char*) sqlite3_column_text(stmt, 2)); + 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)); + } + } + sqlite3_finalize(stmt); + } + else + { std::cerr << sqlite3_errmsg(job_data->db) << std::endl; - } - sqlite3_free(query); - g_free(search); + } + sqlite3_free(query); + g_free(search); } void pk_backend_get_details(PkBackendJob *job, char **package_ids) { - char *homepage = nullptr; - char** tokens; - gsize i; - GString *desc; - GRegex *expr; - GMatchInfo *match_info; - GError *err = nullptr; - sqlite3_stmt *stmt; - auto job_data = static_cast (pk_backend_job_get_user_data(job)); + char *homepage = nullptr; + char** tokens; + gsize i; + GString *desc; + GRegex *expr; + GMatchInfo *match_info; + GError *err = nullptr; + sqlite3_stmt *stmt; + auto job_data = static_cast(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'", - -1, - &stmt, - nullptr) != SQLITE_OK)) { + 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'", + -1, + &stmt, + nullptr) != SQLITE_OK)) { std::cerr << sqlite3_errmsg(job_data->db) << std::endl; - goto out; - } + 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); - g_strfreev(tokens); + 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); + g_strfreev(tokens); - if (sqlite3_step(stmt) != SQLITE_ROW) - goto out; + if (sqlite3_step(stmt) != SQLITE_ROW) + { + goto out; + } + desc = g_string_new((char *) sqlite3_column_text(stmt, 0)); - desc = g_string_new((char *) sqlite3_column_text(stmt, 0)); - - /* Regular expression for searching a homepage */ - expr = g_regex_new("(?:http|ftp):\\/\\/[[:word:]\\/\\-\\.]+[[:word:]\\/](?=\\.?$)", - (GRegexCompileFlags)(G_REGEX_OPTIMIZE | G_REGEX_DUPNAMES), - (GRegexMatchFlags)(0), - &err); - if (err) - { + /* Regular expression for searching a homepage */ + expr = g_regex_new("(?:http|ftp):\\/\\/[[:word:]\\/\\-\\.]+[[:word:]\\/](?=\\.?$)", + (GRegexCompileFlags)(G_REGEX_OPTIMIZE | G_REGEX_DUPNAMES), + (GRegexMatchFlags)(0), + &err); + if (err) + { std::cerr << err->message << std::endl; - g_error_free(err); - goto out; - } - if (g_regex_match(expr, desc->str, (GRegexMatchFlags)0, &match_info)) - { - homepage = g_match_info_fetch(match_info, 0); /* URL */ - /* Remove the last sentence with the copied URL */ - for (i = desc->len - 1; i > 0; i--) - { - if ((desc->str[i - 1] == '.') && (desc->str[i] == ' ')) - { - g_string_truncate(desc, i); - break; - } - } - g_match_info_free(match_info); - } - g_regex_unref(expr); + g_error_free(err); + goto out; + } + if (g_regex_match(expr, desc->str, (GRegexMatchFlags) 0, &match_info)) + { + homepage = g_match_info_fetch(match_info, 0); /* URL */ + /* Remove the last sentence with the copied URL */ + for (i = desc->len - 1; i > 0; i--) + { + if ((desc->str[i - 1] == '.') && (desc->str[i] == ' ')) + { + g_string_truncate(desc, i); + break; + } + } + g_match_info_free(match_info); + } + 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); + /* 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); - g_free(homepage); - if (desc) - { - g_string_free(desc, true); - } + g_free(homepage); + if (desc) + { + g_string_free(desc, true); + } out: - sqlite3_finalize(stmt); + sqlite3_finalize(stmt); } void pk_backend_resolve(PkBackendJob *job, char **packages) { - char **val; - sqlite3_stmt *stmt; - PkInfoEnum ret; - auto job_data = static_cast (pk_backend_job_get_user_data(job)); + char **val; + sqlite3_stmt *stmt; + PkInfoEnum ret; + auto job_data = static_cast(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, " - "p1.full_name FROM pkglist AS p1 NATURAL JOIN repos AS r " - "WHERE p1.name LIKE @search AND p1.repo_order = " - "(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)", - -1, - &stmt, - nullptr) == SQLITE_OK)) { - /* Output packages matching each pattern */ - for (val = packages; *val; val++) - { - sqlite3_bind_text(stmt, 1, *val, -1, SQLITE_TRANSIENT); + if ((sqlite3_prepare_v2(job_data->db, + "SELECT (p1.name || ';' || p1.ver || ';' || p1.arch || ';' || r.repo), p1.summary, " + "p1.full_name FROM pkglist AS p1 NATURAL JOIN repos AS r " + "WHERE p1.name LIKE @search AND p1.repo_order = " + "(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)", + -1, + &stmt, + nullptr) == SQLITE_OK)) { + /* Output packages matching each pattern */ + for (val = packages; *val; val++) + { + sqlite3_bind_text(stmt, 1, *val, -1, SQLITE_TRANSIENT); - while (sqlite3_step(stmt) == SQLITE_ROW) - { + while (sqlite3_step(stmt) == SQLITE_ROW) + { if ((ret == Info::installed) || (ret == Info::updating)) - { - pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED, - (char*) sqlite3_column_text(stmt, 0), - (char*) sqlite3_column_text(stmt, 1)); - } - else if (ret == PK_INFO_ENUM_INSTALLING) - { - pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE, - (char*) sqlite3_column_text(stmt, 0), - (char*) sqlite3_column_text(stmt, 1)); - } - } + { + 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)); + } + } - sqlite3_clear_bindings(stmt); - sqlite3_reset(stmt); - } - sqlite3_finalize(stmt); - } + sqlite3_clear_bindings(stmt); + sqlite3_reset(stmt); + } + sqlite3_finalize(stmt); + } else { std::cerr << sqlite3_errmsg(job_data->db) << std::endl; - } + } } void pk_backend_download_packages(PkBackendJob *job, char **package_ids, const char *directory) { - char *path, *to_strv[] = {nullptr, nullptr}; - unsigned i; - sqlite3_stmt *stmt; - auto job_data = static_cast (pk_backend_job_get_user_data(job)); + char *path, *to_strv[] = {nullptr, nullptr}; + unsigned i; + sqlite3_stmt *stmt; + auto job_data = static_cast(pk_backend_job_get_user_data(job)); - if ((sqlite3_prepare_v2(job_data->db, - "SELECT summary, (full_name || '.' || ext) FROM pkglist NATURAL JOIN repos " - "WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo", - -1, - &stmt, - nullptr) != SQLITE_OK)) - { + if ((sqlite3_prepare_v2(job_data->db, + "SELECT summary, (full_name || '.' || ext) FROM pkglist NATURAL JOIN repos " + "WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo", + -1, + &stmt, + nullptr) != SQLITE_OK)) + { std::cerr << sqlite3_errmsg(job_data->db) << std::endl; - goto out; - } + goto out; + } - for (i = 0; package_ids[i]; ++i) - { - char **tokens = pk_package_id_split(package_ids[i]); + for (i = 0; package_ids[i]; ++i) + { + char **tokens = pk_package_id_split(package_ids[i]); - 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); - if (sqlite3_step(stmt) == SQLITE_ROW) - { - GSList *repo; - if ((repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo))) - { - pk_backend_job_package(job, PK_INFO_ENUM_DOWNLOADING, - package_ids[i], - (char *) sqlite3_column_text(stmt, 0)); - static_cast (repo->data)->download (job, - directory, tokens[PK_PACKAGE_ID_NAME]); - path = g_build_filename(directory, (char *) sqlite3_column_text(stmt, 1), nullptr); - to_strv[0] = path; - pk_backend_job_files(job, nullptr, to_strv); - g_free(path); - } - } - sqlite3_clear_bindings(stmt); - sqlite3_reset(stmt); - g_strfreev(tokens); - } + 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); + if (sqlite3_step(stmt) == SQLITE_ROW) + { + GSList *repo; + if ((repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo))) + { + static_cast(repo->data)->download(job, + directory, tokens[PK_PACKAGE_ID_NAME]); + path = g_build_filename(directory, (char *) sqlite3_column_text(stmt, 1), nullptr); + to_strv[0] = path; + pk_backend_job_files(job, nullptr, to_strv); + g_free(path); + } + } + sqlite3_clear_bindings(stmt); + sqlite3_reset(stmt); + g_strfreev(tokens); + } out: - sqlite3_finalize(stmt); + sqlite3_finalize(stmt); } void pk_backend_install_packages(PkBackendJob *job, 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 (pk_backend_job_get_user_data(job)); + 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(pk_backend_job_get_user_data(job)); - if ((sqlite3_prepare_v2(job_data->db, - "SELECT summary, cat FROM pkglist NATURAL JOIN repos " - "WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo", - -1, - &pkglist_stmt, - nullptr) != SQLITE_OK) || - (sqlite3_prepare_v2(job_data->db, - "SELECT (c.collection_pkg || ';' || p.ver || ';' || p.arch || ';' || r.repo), p.summary, " - "p.full_name, p.ext FROM collections AS c " - "JOIN pkglist AS p ON c.collection_pkg = p.name " - "JOIN repos AS r ON p.repo_order = r.repo_order " - "WHERE c.name LIKE @name AND r.repo LIKE @repo", - -1, - &collection_stmt, - nullptr) != SQLITE_OK)) - { + if ((sqlite3_prepare_v2(job_data->db, + "SELECT summary, cat FROM pkglist NATURAL JOIN repos " + "WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo", + -1, + &pkglist_stmt, + nullptr) != SQLITE_OK) || + (sqlite3_prepare_v2(job_data->db, + "SELECT (c.collection_pkg || ';' || p.ver || ';' || p.arch || ';' || r.repo), p.summary, " + "p.full_name, p.ext FROM collections AS c " + "JOIN pkglist AS p ON c.collection_pkg = p.name " + "JOIN repos AS r ON p.repo_order = r.repo_order " + "WHERE c.name LIKE @name AND r.repo LIKE @repo", + -1, + &collection_stmt, + nullptr) != SQLITE_OK)) + { std::cerr << sqlite3_errmsg(job_data->db) << std::endl; - goto out; - } + goto out; + } - 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); + 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); - if (sqlite3_step(pkglist_stmt) == SQLITE_ROW) - { - /* If it isn't a collection */ - if (g_strcmp0((char *) sqlite3_column_text(pkglist_stmt, 1), "collections")) - { + if (sqlite3_step(pkglist_stmt) == SQLITE_ROW) + { + /* If it isn't a collection */ + if (g_strcmp0((char *) sqlite3_column_text(pkglist_stmt, 1), "collections")) + { install_list = g_slist_append(install_list, g_strdup(package_ids[i])); - } - 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); + } + 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); - while (sqlite3_step(collection_stmt) == SQLITE_ROW) - { - ret = is_installed((char*) sqlite3_column_text(collection_stmt, 2)); - if ((ret == Info::installing) || (ret == Info::updating)) - { + while (sqlite3_step(collection_stmt) == SQLITE_ROW) + { + ret = is_installed((char*) sqlite3_column_text(collection_stmt, 2)); + if ((ret == Info::installing) || (ret == Info::updating)) + { install_list = g_slist_append(install_list, g_strdup((char *) sqlite3_column_text(collection_stmt, 0))); - } - } - sqlite3_clear_bindings(collection_stmt); - sqlite3_reset(collection_stmt); - } - } + } + } + sqlite3_clear_bindings(collection_stmt); + sqlite3_reset(collection_stmt); + } + } - sqlite3_clear_bindings(pkglist_stmt); - sqlite3_reset(pkglist_stmt); - g_strfreev(tokens); - } + sqlite3_clear_bindings(pkglist_stmt); + sqlite3_reset(pkglist_stmt); + g_strfreev(tokens); + } - if (install_list) - { - /* / 2 means total percentage for installing and for downloading */ - percent_step = 100.0 / g_slist_length(install_list) / 2; + if (install_list) + { + /* / 2 means total percentage for installing and for downloading */ + percent_step = 100.0 / g_slist_length(install_list) / 2; - /* Download the packages */ - dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", nullptr); - for (l = install_list, i = 0; l; l = g_slist_next(l), i++) - { - char **tokens; - GSList *repo; + /* Download the packages */ + dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", nullptr); + for (l = install_list, i = 0; l; l = g_slist_next(l), i++) + { + 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); + 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); - if (repo) - { - static_cast (repo->data)->download (job, - dest_dir_name, tokens[PK_PACKAGE_ID_NAME]); - } - g_strfreev(tokens); - } - g_free(dest_dir_name); + if (repo) + { + static_cast(repo->data)->download(job, + dest_dir_name, tokens[PK_PACKAGE_ID_NAME]); + } + g_strfreev(tokens); + } + g_free(dest_dir_name); - /* Install the packages */ - for (l = install_list; l; l = g_slist_next(l), i++) - { - char **tokens; - GSList *repo; + /* Install the packages */ + for (l = install_list; l; l = g_slist_next(l), i++) + { + 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); + 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); - if (repo) - { - static_cast (repo->data)->install (job, tokens[PK_PACKAGE_ID_NAME]); - } - g_strfreev(tokens); - } - } - g_slist_free_full(install_list, g_free); + if (repo) + { + static_cast(repo->data)->install(job, tokens[PK_PACKAGE_ID_NAME]); + } + g_strfreev(tokens); + } + } + g_slist_free_full(install_list, g_free); out: - sqlite3_finalize(pkglist_stmt); - sqlite3_finalize(collection_stmt); + sqlite3_finalize(pkglist_stmt); + sqlite3_finalize(collection_stmt); } void pk_backend_remove_packages(PkBackendJob *job, char **package_ids) { - char *cmd_line; - unsigned i; - gdouble percent_step; - GError *err = nullptr; + char *cmd_line; + unsigned i; + gdouble percent_step; + GError *err = nullptr; /* Add percent_step percents per removed package */ percent_step = 100.0 / g_strv_length(package_ids); @@ -616,109 +580,92 @@ void pk_backend_remove_packages(PkBackendJob *job, char **package_ids) void pk_backend_get_updates(PkBackendJob *job) { - char *pkg_id, *full_name, *desc; - const char *pkg_metadata_filename; - GFile *pkg_metadata_dir; - GFileEnumerator *pkg_metadata_enumerator; - GFileInfo *pkg_metadata_file_info; - GError *err = nullptr; - sqlite3_stmt *stmt; - auto job_data = static_cast (pk_backend_job_get_user_data(job)); + char *pkg_id, *full_name, *desc; + const char *pkg_metadata_filename; + GFile *pkg_metadata_dir; + GFileEnumerator *pkg_metadata_enumerator; + GFileInfo *pkg_metadata_file_info; + GError *err = nullptr; + sqlite3_stmt *stmt; + auto job_data = static_cast(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 " - "FROM pkglist AS p1 NATURAL JOIN repos AS r " - "WHERE p1.name LIKE @name AND p1.repo_order = " - "(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)", - -1, - &stmt, - nullptr) != SQLITE_OK)) - { + if ((sqlite3_prepare_v2(job_data->db, + "SELECT p1.full_name, p1.name, p1.ver, p1.arch, r.repo, p1.summary, p1.ext " + "FROM pkglist AS p1 NATURAL JOIN repos AS r " + "WHERE p1.name LIKE @name AND p1.repo_order = " + "(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)", + -1, + &stmt, + nullptr) != SQLITE_OK)) + { std::cerr << sqlite3_errmsg(job_data->db) << std::endl; - goto out; - } + goto out; + } - /* Read the package metadata directory and comprare all installed packages with ones in the cache */ - pkg_metadata_dir = g_file_new_for_path("/var/log/packages"); - pkg_metadata_enumerator = g_file_enumerate_children(pkg_metadata_dir, "standard::name", - G_FILE_QUERY_INFO_NONE, - nullptr, - &err); - g_object_unref(pkg_metadata_dir); - if (err) - { + /* Read the package metadata directory and comprare all installed packages with ones in the cache */ + pkg_metadata_dir = g_file_new_for_path("/var/log/packages"); + pkg_metadata_enumerator = g_file_enumerate_children(pkg_metadata_dir, "standard::name", + G_FILE_QUERY_INFO_NONE, + nullptr, + &err); + g_object_unref(pkg_metadata_dir); + if (err) + { std::cerr << "/var/log/packages: " << err->message << std::endl; - g_error_free(err); - goto out; - } + g_error_free(err); + goto out; + } - while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, nullptr, nullptr))) - { - char **tokens; + while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, nullptr, nullptr))) + { + char **tokens; - pkg_metadata_filename = g_file_info_get_name(pkg_metadata_file_info); - tokens = split_package_name(pkg_metadata_filename); + pkg_metadata_filename = g_file_info_get_name(pkg_metadata_file_info); + tokens = split_package_name(pkg_metadata_filename); - /* Select the package from the database */ - sqlite3_bind_text(stmt, 1, tokens[0], -1, SQLITE_TRANSIENT); + /* Select the package from the database */ + sqlite3_bind_text(stmt, 1, tokens[0], -1, SQLITE_TRANSIENT); - /* If there are more packages with the same name, remember the one from the - * repository with the lowest order. */ - if ((sqlite3_step(stmt) == SQLITE_ROW) - || g_slist_find_custom(repos, ((char *) sqlite3_column_text(stmt, 4)), cmp_repo)) - { + /* If there are more packages with the same name, remember the one from the + * repository with the lowest order. */ + if ((sqlite3_step(stmt) == SQLITE_ROW) + || g_slist_find_custom(repos, ((char *) sqlite3_column_text(stmt, 4)), cmp_repo)) + { - full_name = g_strdup((char *) sqlite3_column_text(stmt, 0)); + full_name = g_strdup((char *) sqlite3_column_text(stmt, 0)); - if (!g_strcmp0((char *) sqlite3_column_text(stmt, 6), "obsolete")) - { /* Remove if obsolete */ - pkg_id = pk_package_id_build(tokens[PK_PACKAGE_ID_NAME], - tokens[PK_PACKAGE_ID_VERSION], - tokens[PK_PACKAGE_ID_ARCH], - "obsolete"); - /* TODO: - * 1: Use the repository name instead of "obsolete" above and check in pk_backend_update_packages() - if the package is obsolete or not - * 2: Get description from /var/log/packages, not from the database */ - desc = g_strdup((char *) sqlite3_column_text(stmt, 5)); + if (g_strcmp0(pkg_metadata_filename, full_name)) + { /* Update available */ + pkg_id = pk_package_id_build((char *) sqlite3_column_text(stmt, 1), + (char *) sqlite3_column_text(stmt, 2), + (char *) sqlite3_column_text(stmt, 3), + (char *) sqlite3_column_text(stmt, 4)); + desc = g_strdup((char *) sqlite3_column_text(stmt, 5)); - pk_backend_job_package(job, PK_INFO_ENUM_REMOVING, pkg_id, desc); + pk_backend_job_package(job, katja::Info::updating, pkg_id, desc); - g_free(desc); - g_free(pkg_id); - } - else if (g_strcmp0(pkg_metadata_filename, full_name)) - { /* Update available */ - pkg_id = pk_package_id_build((char *) sqlite3_column_text(stmt, 1), - (char *) sqlite3_column_text(stmt, 2), - (char *) sqlite3_column_text(stmt, 3), - (char *) sqlite3_column_text(stmt, 4)); - desc = g_strdup((char *) sqlite3_column_text(stmt, 5)); + g_free(desc); + g_free(pkg_id); + } + g_free(full_name); + } - pk_backend_job_package(job, PK_INFO_ENUM_NORMAL, pkg_id, desc); + sqlite3_clear_bindings(stmt); + sqlite3_reset(stmt); - g_free(desc); - g_free(pkg_id); - } - g_free(full_name); - } - - sqlite3_clear_bindings(stmt); - sqlite3_reset(stmt); - - g_strfreev(tokens); - g_object_unref(pkg_metadata_file_info); - } - g_object_unref(pkg_metadata_enumerator); + g_strfreev(tokens); + g_object_unref(pkg_metadata_file_info); + } + g_object_unref(pkg_metadata_enumerator); out: - sqlite3_finalize(stmt); + sqlite3_finalize(stmt); } -void pk_backend_update_packages(PkBackendJob *job, char **package_ids) +void pk_backend_update_packages(JobData *job_data, char **package_ids) { - char *dest_dir_name, *cmd_line; - unsigned i; + char *dest_dir_name, *cmd_line; + unsigned i; /* Download the packages */ dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", nullptr); @@ -732,7 +679,7 @@ void pk_backend_update_packages(PkBackendJob *job, char **package_ids) if (repo) { - static_cast (repo->data)->download (job, + static_cast(repo->data)->download(job_data, dest_dir_name, tokens[PK_PACKAGE_ID_NAME]); } } @@ -752,7 +699,7 @@ void pk_backend_update_packages(PkBackendJob *job, char **package_ids) if (repo) { - static_cast (repo->data)->install (job, + static_cast(repo->data)->install(job_data, tokens[PK_PACKAGE_ID_NAME]); } } @@ -765,122 +712,99 @@ void pk_backend_update_packages(PkBackendJob *job, char **package_ids) g_free(cmd_line); } g_strfreev(tokens); - } + } } -void pk_backend_refresh_cache(PkBackendJob *job, bool force) +void pk_backend_refresh_cache(JobData *job_data, bool force) { - char *tmp_dir_name, *db_err, *path = nullptr; - int ret; - GSList *file_list = nullptr; - GFile *db_file = nullptr; - GFileInfo *file_info = nullptr; - GError *err = nullptr; - sqlite3_stmt *stmt = nullptr; - auto job_data = static_cast (pk_backend_job_get_user_data(job)); + char *tmp_dir_name, *db_err, *path = nullptr; + int ret; + GSList *file_list = nullptr; + GFile *db_file = nullptr; + GFileInfo *file_info = nullptr; + GError *err = nullptr; + sqlite3_stmt *stmt = nullptr; - /* Create temporary directory */ - tmp_dir_name = g_dir_make_tmp("PackageKit.XXXXXX", &err); - if (!tmp_dir_name) - { + /* Create temporary directory */ + tmp_dir_name = g_dir_make_tmp("PackageKit.XXXXXX", &err); + if (!tmp_dir_name) + { std::cerr << err->message << std::endl; - g_error_free(err); - return; - } + g_error_free(err); + return; + } - /* Force the complete cache refresh if the read configuration file is newer than the metadata cache */ - if (!force) - { - path = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", nullptr); - db_file = g_file_new_for_path(path); - file_info = g_file_query_info(db_file, "time::modified-usec", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, nullptr, &err); - if (err) - { + /* Force the complete cache refresh if the read configuration file is newer than the metadata cache */ + if (!force) + { + path = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", nullptr); + db_file = g_file_new_for_path(path); + file_info = g_file_query_info(db_file, "time::modified-usec", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, nullptr, &err); + if (err) + { std::cerr << path << ": " << err->message; - g_error_free(err); - goto out; - } - ret = sqlite3_prepare_v2(job_data->db, - "SELECT value FROM cache_info WHERE key LIKE 'last_modification'", - -1, - &stmt, - nullptr); - if ((ret != SQLITE_OK) || ((ret = sqlite3_step(stmt)) != SQLITE_ROW)) - { + g_error_free(err); + goto out; + } + ret = sqlite3_prepare_v2(job_data->db, + "SELECT value FROM cache_info WHERE key LIKE 'last_modification'", + -1, + &stmt, + nullptr); + if ((ret != SQLITE_OK) || ((ret = sqlite3_step(stmt)) != SQLITE_ROW)) + { std::cerr << path << ": " << sqlite3_errstr(ret) << std::endl; - goto out; - } - if ((std::uint32_t) sqlite3_column_int(stmt, 0) > g_file_info_get_attribute_uint32(file_info, "time::modified-usec")) - { - force = true; - } - } - if (force) /* It should empty all tables */ - { - if (sqlite3_exec(job_data->db, "DELETE FROM repos", nullptr, 0, &db_err) != SQLITE_OK) - { + goto out; + } + if ((std::uint32_t) sqlite3_column_int(stmt, 0) > g_file_info_get_attribute_uint32(file_info, "time::modified-usec")) + { + force = true; + } + } + if (force) /* It should empty all tables */ + { + if (sqlite3_exec(job_data->db, "DELETE FROM repos", nullptr, 0, &db_err) != SQLITE_OK) + { std::cerr << db_err << std::endl; - sqlite3_free(db_err); - goto out; - } - } + sqlite3_free(db_err); + goto out; + } + } - // Get list of files that should be downloaded. - for (GSList *l = repos; l; l = g_slist_next(l)) - { - file_list = g_slist_concat(file_list, - static_cast (l->data)->collect_cache_info (tmp_dir_name)); - } + // Get list of files that should be downloaded. + for (GSList *l = repos; l; l = g_slist_next(l)) + { + file_list = g_slist_concat(file_list, + static_cast(l->data)->collect_cache_info(tmp_dir_name)); + } - /* Download repository */ - for (GSList *l = file_list; l; l = g_slist_next(l)) - { - get_file(&job_data->curl, static_cast (l->data)[0], - static_cast (l->data)[1]); - } - g_slist_free_full(file_list, (GDestroyNotify)g_strfreev); + /* Download repository */ + for (GSList *l = file_list; l; l = g_slist_next(l)) + { + get_file(&job_data->curl, static_cast(l->data)[0], + static_cast(l->data)[1]); + } + g_slist_free_full(file_list, (GDestroyNotify) g_strfreev); - /* Refresh cache */ - for (GSList *l = repos; l; l = g_slist_next(l)) - { - static_cast (l->data)->generate_cache (job, tmp_dir_name); - } + /* Refresh cache */ + for (GSList *l = repos; l; l = g_slist_next(l)) + { + static_cast(l->data)->generate_cache(job_data, tmp_dir_name); + } out: - sqlite3_finalize(stmt); - if (file_info) - { - g_object_unref(file_info); - } - if (db_file) - { - g_object_unref(db_file); - } - g_free(path); + sqlite3_finalize(stmt); + if (file_info) + { + g_object_unref(file_info); + } + if (db_file) + { + g_object_unref(db_file); + } + g_free(path); - pk_directory_remove_contents(tmp_dir_name); - g_rmdir(tmp_dir_name); - g_free(tmp_dir_name); -} - -void pk_backend_get_update_detail(PkBackendJob *job, char **package_ids) -{ - unsigned i; - - for (i = 0; package_ids[i] != nullptr; i++) - { - pk_backend_job_update_detail (job, - package_ids[i], - nullptr, - nullptr, - nullptr, - nullptr, - nullptr, - PK_RESTART_ENUM_NONE, - nullptr, - nullptr, - PK_UPDATE_STATE_ENUM_STABLE, - nullptr, - nullptr); - } + pk_directory_remove_contents(tmp_dir_name); + g_rmdir(tmp_dir_name); + g_free(tmp_dir_name); } diff --git a/backend/job.h b/backend/job.h index 01d0097..4dff1b9 100644 --- a/backend/job.h +++ b/backend/job.h @@ -6,16 +6,15 @@ #pragma once #include +#include "utils.h" void pk_backend_initialize(GKeyFile *conf); void pk_backend_destroy(); -void pk_backend_start_job(PkBackendJob *job); -void pk_backend_stop_job(PkBackendJob *job); +katja::JobData *pk_backend_start_job(); +void pk_backend_stop_job(katja::JobData *job_data) -void pk_backend_search_names(PkBackendJob *job, char **values); -void pk_backend_search_details(PkBackendJob *job, char **values); -void pk_backend_search_groups(PkBackendJob *job, char **values); +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_get_details(PkBackendJob *job, char **package_ids); @@ -26,6 +25,5 @@ void pk_backend_install_packages(PkBackendJob *job, char **package_ids); void pk_backend_remove_packages(PkBackendJob *job, char **package_ids); void pk_backend_get_updates(PkBackendJob *job); -void pk_backend_update_packages(PkBackendJob *job, char **package_ids); -void pk_backend_refresh_cache(PkBackendJob *job, bool force); -void pk_backend_get_update_detail(PkBackendJob *job, char **package_ids); +void pk_backend_update_packages(katja::JobData *job_data, char **package_ids); +void pk_backend_refresh_cache(katja::JobData *job, bool force); diff --git a/backend/pkgtools.cc b/backend/pkgtools.cc index ebbd838..940ce19 100644 --- a/backend/pkgtools.cc +++ b/backend/pkgtools.cc @@ -12,7 +12,7 @@ namespace katja { /** * katja::Pkgtools::download: - * @job: A #PkBackendJob. + * @job_data: A #JobData. * @dest_dir_name: Destination directory. * @pkg_name: Package name. * @@ -20,57 +20,47 @@ 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, char *dest_dir_name, char *pkg_name) noexcept { - char *dest_filename, *source_url; - bool ret = false; - sqlite3_stmt *statement = nullptr; - CURL *curl = nullptr; + char *dest_filename, *source_url; + bool ret = false; + sqlite3_stmt *statement = nullptr; + CURL *curl = nullptr; - if ((sqlite3_prepare_v2(job_data->db, - "SELECT location, (full_name || '.' || ext) FROM pkglist " - "WHERE name LIKE @name AND repo_order = @repo_order", - -1, - &statement, - nullptr) != SQLITE_OK)) - return false; + if ((sqlite3_prepare_v2(job_data->db, + "SELECT location, (full_name || '.' || ext) FROM pkglist " + "WHERE name LIKE @name AND repo_order = @repo_order", + -1, + &statement, + nullptr) != SQLITE_OK)) + { + return false; + } + sqlite3_bind_text(statement, 1, pkg_name, -1, SQLITE_TRANSIENT); + sqlite3_bind_int(statement, 2, this->get_order()); - sqlite3_bind_text(statement, 1, pkg_name, -1, SQLITE_TRANSIENT); - sqlite3_bind_int(statement, 2, this->get_order ()); + if (sqlite3_step(statement) == SQLITE_ROW) + { + dest_filename = g_build_filename(dest_dir_name, sqlite3_column_text(statement, 1), nullptr); + source_url = g_strconcat(this->get_mirror(), + sqlite3_column_text(statement, 0), + "/", + sqlite3_column_text(statement, 1), + nullptr); - if (sqlite3_step(statement) == SQLITE_ROW) - { - dest_filename = g_build_filename(dest_dir_name, sqlite3_column_text(statement, 1), nullptr); - source_url = g_strconcat(this->get_mirror (), - sqlite3_column_text(statement, 0), - "/", - sqlite3_column_text(statement, 1), - nullptr); + ret = g_file_test(dest_filename, G_FILE_TEST_EXISTS) + || get_file(&curl, source_url, dest_filename) == CURLE_OK; - if (!g_file_test(dest_filename, G_FILE_TEST_EXISTS)) - { - if (get_file(&curl, source_url, dest_filename) == CURLE_OK) - { - ret = true; - } - } - else - { - ret = true; - } + if (curl) + { + curl_easy_cleanup(curl); + } + g_free(source_url); + g_free(dest_filename); + } + sqlite3_finalize(statement); - if (curl) - { - curl_easy_cleanup(curl); - } - g_free(source_url); - g_free(dest_filename); - } - sqlite3_finalize(statement); - - return ret; + return ret; } /** @@ -80,43 +70,42 @@ Pkgtools::download (JobData *job_data, * * Install a package. **/ -void -Pkgtools::install (JobData *job_data, char *pkg_name) noexcept +void Pkgtools::install(JobData *job_data, char *pkg_name) noexcept { - char *pkg_filename, *cmd_line; - sqlite3_stmt *statement = nullptr; + char *pkg_filename, *cmd_line; + sqlite3_stmt *statement = nullptr; - if ((sqlite3_prepare_v2(job_data->db, - "SELECT (full_name || '.' || ext) FROM pkglist " - "WHERE name LIKE @name AND repo_order = @repo_order", - -1, - &statement, - nullptr) != SQLITE_OK)) - { - return; - } + if ((sqlite3_prepare_v2(job_data->db, + "SELECT (full_name || '.' || ext) FROM pkglist " + "WHERE name LIKE @name AND repo_order = @repo_order", + -1, + &statement, + nullptr) != SQLITE_OK)) + { + return; + } - sqlite3_bind_text(statement, 1, pkg_name, -1, SQLITE_TRANSIENT); - sqlite3_bind_int(statement, 2, this->get_order ()); + sqlite3_bind_text(statement, 1, pkg_name, -1, SQLITE_TRANSIENT); + sqlite3_bind_int(statement, 2, this->get_order()); - if (sqlite3_step(statement) == SQLITE_ROW) - { - pkg_filename = g_build_filename(LOCALSTATEDIR, - "cache", - "PackageKit", - "downloads", - sqlite3_column_text(statement, 0), - nullptr); - cmd_line = g_strconcat("/sbin/upgradepkg --install-new ", pkg_filename, nullptr); - g_spawn_command_line_sync(cmd_line, nullptr, nullptr, nullptr, nullptr); - g_free(cmd_line); + if (sqlite3_step(statement) == SQLITE_ROW) + { + pkg_filename = g_build_filename(LOCALSTATEDIR, + "cache", + "PackageKit", + "downloads", + sqlite3_column_text(statement, 0), + nullptr); + cmd_line = g_strconcat("/sbin/upgradepkg --install-new ", pkg_filename, nullptr); + g_spawn_command_line_sync(cmd_line, nullptr, nullptr, nullptr, nullptr); + g_free(cmd_line); - g_free(pkg_filename); - } - sqlite3_finalize(statement); + g_free(pkg_filename); + } + sqlite3_finalize(statement); } -Pkgtools::~Pkgtools () noexcept +Pkgtools::~Pkgtools() noexcept { } @@ -127,10 +116,9 @@ Pkgtools::~Pkgtools () noexcept * * Returns: Repository name. **/ -const char * -Pkgtools::get_name () const noexcept +const char *Pkgtools::get_name() const noexcept { - return this->name; + return this->name; } /** @@ -140,10 +128,9 @@ Pkgtools::get_name () const noexcept * * Returns: Repository mirror. **/ -const char * -Pkgtools::get_mirror () const noexcept +const char *Pkgtools::get_mirror() const noexcept { - return this->mirror; + return this->mirror; } /** @@ -153,10 +140,9 @@ Pkgtools::get_mirror () const noexcept * * Returns: Repository order. **/ -guint8 -Pkgtools::get_order () const noexcept +guint8 Pkgtools::get_order() const noexcept { - return this->order; + return this->order; } /** @@ -167,12 +153,10 @@ Pkgtools::get_order () const noexcept * * Returns: %TRUE if the package is blacklisted, %FALSE otherwise. **/ -bool -Pkgtools::is_blacklisted (const char *pkg) const noexcept +bool Pkgtools::is_blacklisted(const char *pkg) const noexcept { - return this->blacklist - && g_regex_match (this->blacklist, - pkg, static_cast (0), nullptr); + return this->blacklist + && g_regex_match (this->blacklist, pkg, static_cast(0), nullptr); } } diff --git a/backend/pkgtools.h b/backend/pkgtools.h index e51b4b9..4bf5174 100644 --- a/backend/pkgtools.h +++ b/backend/pkgtools.h @@ -14,26 +14,23 @@ namespace katja class Pkgtools { public: - const char *get_name () const noexcept; - const char *get_mirror () const noexcept; - std::uint8_t get_order () const noexcept; - bool is_blacklisted (const char *pkg) const noexcept; + const char *get_name() const noexcept; + const char *get_mirror() const noexcept; + std::uint8_t get_order() const noexcept; + bool is_blacklisted(const char *pkg) const noexcept; - virtual ~Pkgtools () noexcept; + virtual ~Pkgtools() noexcept; - bool download (JobData *job_data, - char *dest_dir_name, char *pkg_name) noexcept; - void install (JobData *job_data, char *pkg_name) noexcept; + bool download(JobData *job_data, 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; - virtual void generate_cache (JobData *job_data, - const char *tmpl) noexcept = 0; + virtual GSList *collect_cache_info (const char *tmpl) noexcept = 0; + virtual void generate_cache(JobData *job_data, const char *tmpl) noexcept = 0; protected: - char *name = nullptr; - char *mirror = nullptr; + char *name = nullptr; + char *mirror = nullptr; std::uint8_t order; - GRegex *blacklist = nullptr; + GRegex *blacklist = nullptr; }; - } diff --git a/backend/slackpkg.cc b/backend/slackpkg.cc index 74a7ecb..a750f2e 100644 --- a/backend/slackpkg.cc +++ b/backend/slackpkg.cc @@ -12,15 +12,14 @@ GHashTable *Slackpkg::cat_map = nullptr; /* * katja::Slackpkg::manifest: - * @job: a #PkBackendJob. + * @job: a #JobData. * @tmpl: temporary directory. * @filename: manifest filename * * Parse the manifest file and save the file list in the database. */ void -Slackpkg::manifest (PkBackendJob *job, - const char *tmpl, char *filename) noexcept +Slackpkg::manifest(JobData *job_data, const char *tmpl, char *filename) noexcept { FILE *manifest; int err, read_len; @@ -32,10 +31,9 @@ Slackpkg::manifest (PkBackendJob *job, GRegex *pkg_expr = nullptr, *file_expr = nullptr; GMatchInfo *match_info; sqlite3_stmt *statement = nullptr; - auto job_data = static_cast (pk_backend_job_get_user_data(job)); path = g_build_filename(tmpl, - this->get_name (), + this->get_name(), filename, nullptr); manifest = fopen(path, "rb"); @@ -169,19 +167,19 @@ Slackpkg::collect_cache_info (const char *tmpl) noexcept /* Create the temporary directory for the repository */ tmp_dir = g_file_new_for_path(tmpl); - repo_tmp_dir = g_file_get_child(tmp_dir, this->get_name ()); + repo_tmp_dir = g_file_get_child(tmp_dir, this->get_name()); g_file_make_directory(repo_tmp_dir, nullptr, nullptr); /* Download PACKAGES.TXT. These files are most important, break if some of them couldn't be found */ for (char **cur_priority = this->priority; *cur_priority; cur_priority++) { source_dest = static_cast (g_malloc_n(3, sizeof(char *))); - source_dest[0] = g_strconcat(this->get_mirror (), + source_dest[0] = g_strconcat(this->get_mirror(), *cur_priority, "/PACKAGES.TXT", nullptr); source_dest[1] = g_build_filename(tmpl, - this->get_name (), + this->get_name(), "PACKAGES.TXT", nullptr); source_dest[2] = nullptr; @@ -199,12 +197,12 @@ Slackpkg::collect_cache_info (const char *tmpl) noexcept /* Download file lists if available */ source_dest = static_cast (g_malloc_n(3, sizeof(char *))); - source_dest[0] = g_strconcat(this->get_mirror (), + source_dest[0] = g_strconcat(this->get_mirror(), *cur_priority, "/MANIFEST.bz2", nullptr); source_dest[1] = g_strconcat(tmpl, - "/", this->get_name (), + "/", this->get_name(), "/", *cur_priority, "-MANIFEST.bz2", nullptr); source_dest[2] = nullptr; @@ -239,7 +237,7 @@ out: * Returns: List of files needed for building the cache. **/ void -Slackpkg::generate_cache (JobData *job_data, const char *tmpl) noexcept +Slackpkg::generate_cache(JobData *job_data, const char *tmpl) noexcept { char **pkg_tokens = nullptr; char *query = nullptr, *filename = nullptr, *location = nullptr, *summary = nullptr, *line, *packages_txt; @@ -252,10 +250,7 @@ Slackpkg::generate_cache (JobData *job_data, const char *tmpl) noexcept sqlite3_stmt *insert_statement = nullptr, *update_statement = nullptr, *insert_default_statement = nullptr, *statement; /* Check if the temporary directory for this repository exists, then the file metadata have to be generated */ - packages_txt = g_build_filename(tmpl, - this->get_name (), - "PACKAGES.TXT", - nullptr); + packages_txt = g_build_filename(tmpl, this->get_name(), "PACKAGES.TXT", nullptr); list_file = g_file_new_for_path(packages_txt); fin = g_file_read(list_file, nullptr, nullptr); g_object_unref(list_file); @@ -271,11 +266,7 @@ Slackpkg::generate_cache (JobData *job_data, const char *tmpl) noexcept &statement, nullptr) == SQLITE_OK) { - sqlite3_bind_text(statement, - 1, - this->get_name (), - -1, - SQLITE_TRANSIENT); + sqlite3_bind_text(statement, 1, this->get_name(), -1, SQLITE_TRANSIENT); sqlite3_step(statement); sqlite3_finalize(statement); } @@ -287,12 +278,8 @@ Slackpkg::generate_cache (JobData *job_data, const char *tmpl) noexcept { goto out; } - sqlite3_bind_int(statement, 1, this->get_order ()); - sqlite3_bind_text(statement, - 2, - this->get_name (), - -1, - SQLITE_TRANSIENT); + sqlite3_bind_int(statement, 1, this->get_order()); + sqlite3_bind_text(statement, 2, this->get_name(), -1, SQLITE_TRANSIENT); sqlite3_step(statement); sqlite3_finalize(statement); @@ -320,7 +307,7 @@ Slackpkg::generate_cache (JobData *job_data, const char *tmpl) noexcept "ext = @ext, location = @location, summary = @summary, " "desc = @desc, compressed = @compressed, uncompressed = @uncompressed " "WHERE name LIKE @name AND repo_order = %u", - this->get_order ()); + this->get_order()); if (sqlite3_prepare_v2(job_data->db, query, -1, &update_statement, nullptr) != SQLITE_OK) { goto out; @@ -392,7 +379,7 @@ Slackpkg::generate_cache (JobData *job_data, const char *tmpl) noexcept { statement = insert_default_statement; } - sqlite3_bind_int(statement, 11, this->get_order ()); + sqlite3_bind_int(statement, 11, this->get_order()); } else /* Update package information if it is a patch */ { @@ -433,7 +420,7 @@ Slackpkg::generate_cache (JobData *job_data, const char *tmpl) noexcept for (char **p = this->priority; *p; p++) { filename = g_strconcat(*p, "-MANIFEST.bz2", nullptr); - manifest (job, tmpl, filename); + manifest(job_data, tmpl, filename); g_free(filename); } out: diff --git a/backend/slackpkg.h b/backend/slackpkg.h index c358dd9..7cda41d 100644 --- a/backend/slackpkg.h +++ b/backend/slackpkg.h @@ -20,15 +20,14 @@ public: ~Slackpkg () noexcept; GSList *collect_cache_info (const char *tmpl) noexcept; - void generate_cache (JobData *job_data, const char *tmpl) noexcept; + void generate_cache(JobData *job_data, const char *tmpl) noexcept; private: static GHashTable *cat_map; static const std::size_t max_buf_size = 8192; char **priority = nullptr; - void manifest (PkBackendJob *job, - const char *tmpl, char *filename) noexcept; + void manifest(JobData *job_data, const char *tmpl, char *filename) noexcept; }; } diff --git a/backend/utils.cc b/backend/utils.cc index 208f150..b69a780 100644 --- a/backend/utils.cc +++ b/backend/utils.cc @@ -22,130 +22,126 @@ namespace katja * * Returns: CURLE_OK (zero) on success, non-zero otherwise. **/ -CURLcode -get_file (CURL **curl, char *source_url, char *dest) +CURLcode get_file(CURL **curl, char *source_url, char *dest) { - char *dest_dir_name; - FILE *fout = nullptr; - CURLcode ret; - glong response_code; + char *dest_dir_name; + FILE *fout = nullptr; + CURLcode ret; + glong response_code; - if ((*curl == nullptr) && (!(*curl = curl_easy_init()))) - { - return CURLE_BAD_FUNCTION_ARGUMENT; - } + if ((*curl == nullptr) && (!(*curl = curl_easy_init()))) + { + return CURLE_BAD_FUNCTION_ARGUMENT; + } - curl_easy_setopt(*curl, CURLOPT_FOLLOWLOCATION, 1L); - curl_easy_setopt(*curl, CURLOPT_URL, source_url); + curl_easy_setopt(*curl, CURLOPT_FOLLOWLOCATION, 1L); + curl_easy_setopt(*curl, CURLOPT_URL, source_url); - if (dest == nullptr) - { - curl_easy_setopt(*curl, CURLOPT_NOBODY, 1L); - curl_easy_setopt(*curl, CURLOPT_HEADER, 1L); - ret = curl_easy_perform(*curl); - curl_easy_getinfo(*curl, CURLINFO_RESPONSE_CODE, &response_code); + if (dest == nullptr) + { + curl_easy_setopt(*curl, CURLOPT_NOBODY, 1L); + curl_easy_setopt(*curl, CURLOPT_HEADER, 1L); + ret = curl_easy_perform(*curl); + curl_easy_getinfo(*curl, CURLINFO_RESPONSE_CODE, &response_code); - if (response_code != 200) - { - ret = CURLE_REMOTE_FILE_NOT_FOUND; - } - } - else - { - if (g_file_test(dest, G_FILE_TEST_IS_DIR)) - { - dest_dir_name = dest; - dest = g_strconcat(dest_dir_name, g_strrstr(source_url, "/"), nullptr); - g_free(dest_dir_name); - } - if ((fout = fopen(dest, "ab")) == nullptr) - { - return CURLE_WRITE_ERROR; - } - curl_easy_setopt(*curl, CURLOPT_WRITEDATA, fout); - ret = curl_easy_perform(*curl); - } - curl_easy_reset(*curl); - if (fout != nullptr) - { - fclose(fout); - } - return ret; + if (response_code != 200) + { + ret = CURLE_REMOTE_FILE_NOT_FOUND; + } + } + else + { + if (g_file_test(dest, G_FILE_TEST_IS_DIR)) + { + dest_dir_name = dest; + dest = g_strconcat(dest_dir_name, g_strrstr(source_url, "/"), nullptr); + g_free(dest_dir_name); + } + if ((fout = fopen(dest, "ab")) == nullptr) + { + return CURLE_WRITE_ERROR; + } + curl_easy_setopt(*curl, CURLOPT_WRITEDATA, fout); + ret = curl_easy_perform(*curl); + } + curl_easy_reset(*curl); + if (fout != nullptr) + { + fclose(fout); + } + return ret; } /** * katja::split_package_name: * Got the name of a package, without version-arch-release data. **/ -char ** -split_package_name (const char *pkg_filename) +char **split_package_name(const char *pkg_filename) { - char *pkg_full_name; - char **pkg_tokens; + char *pkg_full_name; + char **pkg_tokens; - g_return_val_if_fail(pkg_filename != nullptr, nullptr); + g_return_val_if_fail(pkg_filename != nullptr, nullptr); - int len = strlen(pkg_filename); - if (len < 4) - { - return nullptr; - } + int len = strlen(pkg_filename); + if (len < 4) + { + return nullptr; + } - if (pkg_filename[len - 4] == '.') - { - pkg_tokens = static_cast (g_malloc_n (6, sizeof (char *))); + if (pkg_filename[len - 4] == '.') + { + pkg_tokens = static_cast(g_malloc_n (6, sizeof (char *))); - /* Full name without extension */ - len -= 4; - pkg_full_name = g_strndup (pkg_filename, len); - pkg_tokens[3] = g_strdup (pkg_full_name); + /* Full name without extension */ + len -= 4; + pkg_full_name = g_strndup(pkg_filename, len); + pkg_tokens[3] = g_strdup(pkg_full_name); - /* The last 3 characters should be the file extension */ - pkg_tokens[4] = g_strdup (pkg_filename + len + 1); - pkg_tokens[5] = nullptr; - } - else - { - pkg_tokens = static_cast (g_malloc_n (4, sizeof (char *))); - pkg_full_name = g_strdup (pkg_filename); - pkg_tokens[3] = nullptr; - } + /* The last 3 characters should be the file extension */ + pkg_tokens[4] = g_strdup(pkg_filename + len + 1); + pkg_tokens[5] = nullptr; + } + else + { + pkg_tokens = static_cast(g_malloc_n (4, sizeof (char *))); + pkg_full_name = g_strdup(pkg_filename); + pkg_tokens[3] = nullptr; + } - /* Reverse all of the bytes in the package filename to get the name, version and the architecture */ - g_strreverse (pkg_full_name); - char **reversed_tokens = g_strsplit (pkg_full_name, "-", 4); - pkg_tokens[0] = g_strreverse (reversed_tokens[3]); /* Name */ - pkg_tokens[1] = g_strreverse (reversed_tokens[2]); /* Version */ - pkg_tokens[2] = g_strreverse (reversed_tokens[1]); /* Architecture */ + /* Reverse all of the bytes in the package filename to get the name, version and the architecture */ + g_strreverse (pkg_full_name); + char **reversed_tokens = g_strsplit(pkg_full_name, "-", 4); + pkg_tokens[0] = g_strreverse(reversed_tokens[3]); /* Name */ + pkg_tokens[1] = g_strreverse(reversed_tokens[2]); /* Version */ + pkg_tokens[2] = g_strreverse(reversed_tokens[1]); /* Architecture */ - g_free (reversed_tokens[0]); /* Build number */ - g_free (reversed_tokens); - g_free (pkg_full_name); + g_free(reversed_tokens[0]); /* Build number */ + g_free(reversed_tokens); + g_free(pkg_full_name); - return pkg_tokens; + return pkg_tokens; } /** * katja::is_installed: * Checks if a package is already installed in the system. * - * Params: - * pkg_fullname = Package name should be looked for. + * @pkg_fullname: Package name should be looked for. * * Returns: Package installation information. **/ -Info -is_installed (const char *pkg_fullname) +Info is_installed(const char *pkg_fullname) { - GFileEnumerator *pkg_metadata_enumerator; - GFileInfo *pkg_metadata_file_info; - GFile *pkg_metadata_dir; - Info ret = Info::installing; + GFileEnumerator *pkg_metadata_enumerator; + GFileInfo *pkg_metadata_file_info; + GFile *pkg_metadata_dir; + Info ret = Info::installing; const char *it; std::uint8_t dashes = 0; - ptrdiff_t pkg_name; + ptrdiff_t pkg_name; - g_return_val_if_fail(pkg_fullname != nullptr, Info::unknown); + g_return_val_if_fail(pkg_fullname != nullptr, Info::unknown); // We want to find the package name without version for the package we're // looking for. @@ -162,75 +158,73 @@ is_installed (const char *pkg_fullname) ++dashes; } } - if (dashes < 2) - { - return Info::unknown; - } + if (dashes < 2) + { + return Info::unknown; + } pkg_name = it - pkg_fullname; - // Read the package metadata directory and comprare all installed packages + // Read the package metadata directory and comprare all installed packages // with ones in the cache. - pkg_metadata_dir = g_file_new_for_path("/var/log/packages"); - if (!(pkg_metadata_enumerator = g_file_enumerate_children(pkg_metadata_dir, - "standard::name", - G_FILE_QUERY_INFO_NONE, - nullptr, - nullptr))) - { - g_object_unref(pkg_metadata_dir); - return Info::unknown; - } + pkg_metadata_dir = g_file_new_for_path("/var/log/packages"); + if (!(pkg_metadata_enumerator = g_file_enumerate_children(pkg_metadata_dir, + "standard::name", + G_FILE_QUERY_INFO_NONE, + nullptr, + nullptr))) + { + g_object_unref(pkg_metadata_dir); + return Info::unknown; + } - while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, nullptr, nullptr))) - { - const char *dir = g_file_info_get_name(pkg_metadata_file_info); + while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, nullptr, nullptr))) + { + const char *dir = g_file_info_get_name(pkg_metadata_file_info); dashes = 0; if (strcmp(dir, pkg_fullname) == 0) { ret = Info::installed; } - else - { - for (it = dir + strlen(dir); it != dir; --it) - { - if (*it == '-') - { - if (dashes == 2) - { - break; - } - ++dashes; - } - } - if (pkg_name == (it - dir) && strncmp(pkg_fullname, dir, pkg_name) == 0) - { - ret = Info::updating; - } + else + { + for (it = dir + strlen(dir); it != dir; --it) + { + if (*it == '-') + { + if (dashes == 2) + { + break; + } + ++dashes; + } + } + if (pkg_name == (it - dir) && strncmp(pkg_fullname, dir, pkg_name) == 0) + { + ret = Info::updating; + } + } + g_object_unref(pkg_metadata_file_info); - } - g_object_unref(pkg_metadata_file_info); + if (ret != Info::installing) /* If installed */ + { + break; + } + } + g_object_unref(pkg_metadata_enumerator); + g_object_unref(pkg_metadata_dir); - if (ret != Info::installing) /* If installed */ - { - break; - } - } - g_object_unref(pkg_metadata_enumerator); - g_object_unref(pkg_metadata_dir); - - return ret; + return ret; } /** * katja::cmp_repo: **/ -int -cmp_repo (const void *a, const void *b) +int cmp_repo(const void *a, const void *b) { - auto repo = static_cast (a); + auto repo = static_cast (a); - return g_strcmp0 (repo->get_name (), (char *) b); + return g_strcmp0(repo->get_name(), (char *) b); } } diff --git a/backend/utils.h b/backend/utils.h index 66df9a4..b43c2bd 100644 --- a/backend/utils.h +++ b/backend/utils.h @@ -11,8 +11,8 @@ namespace katja { struct JobData { - sqlite3 *db; - CURL *curl; + sqlite3 *db; + CURL *curl; }; enum class Info @@ -24,15 +24,17 @@ enum class Info // A different version is installed. updating, // Available, but not installed. - installing + installing, + // Available. + available }; -CURLcode get_file (CURL **curl, char *source_url, char *dest); +CURLcode get_file(CURL **curl, char *source_url, char *dest); -char **split_package_name (const char *pkg_filename); +char **split_package_name(const char *pkg_filename); -Info is_installed (const char *pkg_fullname); +Info is_installed(const char *pkg_fullname); -int cmp_repo (const void *a, const void *b); +int cmp_repo(const void *a, const void *b); }