OSS/katja
1
0
Fork 0
Code Issues Actions Releases Activity

Rename Glib primitive types to standard C types
Some checks failed
Test / build (push) Failing after 16s
Details

Browse Source
This commit is contained in:
Eugen Wissner
2026-02-27 09:51:29 +01:00
parent 5875f6ac9a
commit 2c65a2c6b0
19 changed files with 563 additions and 566 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
CMakeLists.txt
View File

@@ -6,20 +6,22 @@ cmake_minimum_required(VERSION 4.0.0)
project(Katja LANGUAGES CXX) project(Katja LANGUAGES CXX)
include(CTest) include(CTest)
include(FetchContent)
option(KATJA_BUILD_TUI "Build text user interface" ON) option(KATJA_BUILD_CLI "Build command line interface" ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS 1) set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set(CMAKE_CXX_STANDARD 23) set(CMAKE_CXX_STANDARD 23)
find_package(Boost REQUIRED)
add_library(katja) add_library(katja)
target_sources(katja PUBLIC FILE_SET all_my_modules TYPE CXX_MODULES FILES target_sources(katja PUBLIC FILE_SET all_my_modules TYPE CXX_MODULES FILES
katja/database.cpp katja/repository.cpp katja/sbo.cpp) katja/database.cpp katja/repository.cpp katja/sbo.cpp)
include_directories(include ${Boost_INCLUDE_DIR}) include_directories(include ${Boost_INCLUDE_DIR})
if(KATJA_BUILD_TUI) # add_subdirectory(backend)
if(KATJA_BUILD_CLI)
add_subdirectory(cli) add_subdirectory(cli)
endif() endif()
if(BUILD_TESTING) if(BUILD_TESTING)

56
backend/CMakeLists.txt Normal file
View File

@@ -0,0 +1,56 @@
# 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/.
find_package(PkgConfig REQUIRED)
pkg_check_modules(deps REQUIRED IMPORTED_TARGET glib-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
)
target_link_libraries(backend PkgConfig::deps)
# curl_dep = meson.get_compiler('c').find_library('curl')
# bzip2_dep = dependency('bzip2')
# packagekit_backend_slack_module = shared_module(
# 'pk_backend_slack',
# 'pk-backend-slack.cc',
# 'utils.cc',
# 'pkgtools.cc',
# 'slackpkg.cc',
# 'dl.cc',
# 'job.cc',
# include_directories: packagekit_src_include,
# dependencies: [
# packagekit_glib2_dep,
# curl_dep,
# gmodule_dep,
# sqlite3_dep,
# bzip2_dep,
# ],
# cpp_args: [
# '-DG_LOG_DOMAIN="PackageKit-Slackware"',
# '-DLOCALSTATEDIR="@0@"'.format(join_paths(get_option('prefix'), get_option('localstatedir'))),
# '-DLIBDIR="@0@"'.format(join_paths(get_option('prefix'), get_option('libdir'))),
# '-DSYSCONFDIR="@0@"'.format(get_option('sysconfdir')),
# ],
# override_options: ['c_std=c14', 'cpp_std=c++14'],
# install: true,
# install_dir: pk_plugin_dir,
# )
# configure_file(
# input: 'Slackware.conf.in',
# output: 'Slackware.conf',
# configuration: slackware_config_data,
# install: true,
# install_dir: join_paths(get_option('sysconfdir'), 'PackageKit'),
# )
# install_data(
# 'metadata.db',
# install_dir: join_paths(get_option('localstatedir'), 'cache', 'PackageKit', 'metadata'),
# )

15
backend/Slackware.conf.in
View File

@@ -1,15 +0,0 @@
# It is a sample configuration.
[slackware]
Mirror=http://mirrors.slackware.com/slackware/@pkgmain@-14.2/
Priority=patches;@pkgmain@;extra;pasture;testing
#Blacklist=
#[dropline]
#Mirror=http://dl.flevum.de/slackware/3.10/
#IndexFile=http://dl.flevum.de/slackware/3.10/DroplineFiles3.10
#[dropline]
#Mirror=http://dl.flevum.de/slackware64/3.10/
#IndexFile=http://dl.flevum.de/slackware64/3.10/Dropline64Files3.10

68
backend/dl.cc
View File

@@ -1,3 +1,8 @@
/*
* 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 <sqlite3.h> #include <sqlite3.h>
#include <stdlib.h> #include <stdlib.h>
#include "dl.h" #include "dl.h"
@@ -15,27 +20,27 @@ namespace slack {
* Returns: List of files needed for building the cache. * Returns: List of files needed for building the cache.
**/ **/
GSList * GSList *
Dl::collect_cache_info (const gchar *tmpl) noexcept Dl::collect_cache_info (const char *tmpl) noexcept
{ {
CURL *curl = NULL; CURL *curl = nullptr;
GSList *file_list = NULL; GSList *file_list = nullptr;
GFile *tmp_dir, *repo_tmp_dir; GFile *tmp_dir, *repo_tmp_dir;
/* Create the temporary directory for the repository */ /* Create the temporary directory for the repository */
tmp_dir = g_file_new_for_path(tmpl); 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, NULL, NULL); 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 */ /* 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<gchar **> (g_malloc_n(3, sizeof(gchar *))); auto source_dest = static_cast<char **> (g_malloc_n(3, sizeof(char *)));
source_dest[0] = g_strdup(this->index_file); source_dest[0] = g_strdup(this->index_file);
source_dest[1] = g_build_filename(tmpl, source_dest[1] = g_build_filename(tmpl,
this->get_name (), this->get_name (),
"IndexFile", "IndexFile",
NULL); nullptr);
source_dest[2] = NULL; source_dest[2] = nullptr;
/* Check if the remote file can be found */ /* Check if the remote file can be found */
if (get_file(&curl, source_dest[0], NULL)) if (get_file(&curl, source_dest[0], nullptr))
{ {
g_strfreev(source_dest); g_strfreev(source_dest);
} }
@@ -55,7 +60,7 @@ Dl::collect_cache_info (const gchar *tmpl) noexcept
/** /**
* slack::Dl::generate_cache: * slack::Dl::generate_cache:
* @job: A #PkBackendJob. * @job_data: A #JobData.
* @tmpl: temporary directory for downloading the files. * @tmpl: temporary directory for downloading the files.
* *
* Download files needed to get the information like the list of packages * Download files needed to get the information like the list of packages
@@ -64,23 +69,22 @@ Dl::collect_cache_info (const gchar *tmpl) noexcept
* Returns: List of files needed for building the cache. * Returns: List of files needed for building the cache.
**/ **/
void void
Dl::generate_cache(PkBackendJob *job, const gchar *tmpl) noexcept Dl::generate_cache(JobData *job_data, const char *tmpl) noexcept
{ {
gchar **line_tokens, **pkg_tokens, *line, *collection_name = NULL, *list_filename; char **line_tokens, **pkg_tokens, *line, *collection_name = nullptr, *list_filename;
gboolean skip = FALSE; bool skip = false;
GFile *list_file; GFile *list_file;
GFileInputStream *fin; GFileInputStream *fin;
GDataInputStream *data_in = NULL; GDataInputStream *data_in = nullptr;
sqlite3_stmt *stmt = NULL; sqlite3_stmt *stmt = nullptr;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
/* Check if the temporary directory for this repository exists. If so the file metadata have to be generated */ /* Check if the temporary directory for this repository exists. If so the file metadata have to be generated */
list_filename = g_build_filename(tmpl, list_filename = g_build_filename(tmpl,
this->get_name (), this->get_name (),
"IndexFile", "IndexFile",
NULL); nullptr);
list_file = g_file_new_for_path(list_filename); list_file = g_file_new_for_path(list_filename);
if (!(fin = g_file_read(list_file, NULL, NULL))) if (!(fin = g_file_read(list_file, nullptr, nullptr)))
{ {
goto out; goto out;
} }
@@ -91,7 +95,7 @@ Dl::generate_cache(PkBackendJob *job, const gchar *tmpl) noexcept
"DELETE FROM repos WHERE repo LIKE @repo", "DELETE FROM repos WHERE repo LIKE @repo",
-1, -1,
&stmt, &stmt,
NULL) == SQLITE_OK) { nullptr) == SQLITE_OK) {
sqlite3_bind_text(stmt, 1, this->get_name (), -1, SQLITE_TRANSIENT); sqlite3_bind_text(stmt, 1, this->get_name (), -1, SQLITE_TRANSIENT);
sqlite3_step(stmt); sqlite3_step(stmt);
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
@@ -100,7 +104,7 @@ Dl::generate_cache(PkBackendJob *job, const gchar *tmpl) noexcept
"INSERT INTO repos (repo_order, repo) VALUES (@repo_order, @repo)", "INSERT INTO repos (repo_order, repo) VALUES (@repo_order, @repo)",
-1, -1,
&stmt, &stmt,
NULL) != SQLITE_OK) nullptr) != SQLITE_OK)
{ {
goto out; goto out;
} }
@@ -120,13 +124,13 @@ Dl::generate_cache(PkBackendJob *job, const gchar *tmpl) noexcept
"@desc, @compressed, @uncompressed, @cat, @repo_order, @ext)", "@desc, @compressed, @uncompressed, @cat, @repo_order, @ext)",
-1, -1,
&stmt, &stmt,
NULL) != SQLITE_OK)) nullptr) != SQLITE_OK))
{ {
goto out; goto out;
} }
sqlite3_exec(job_data->db, "BEGIN TRANSACTION", NULL, NULL, NULL); sqlite3_exec(job_data->db, "BEGIN TRANSACTION", nullptr, nullptr, nullptr);
while ((line = g_data_input_stream_read_line(data_in, NULL, NULL, NULL))) while ((line = g_data_input_stream_read_line(data_in, nullptr, nullptr, nullptr)))
{ {
line_tokens = g_strsplit(line, ":", 0); line_tokens = g_strsplit(line, ":", 0);
if ((g_strv_length(line_tokens) > 6) if ((g_strv_length(line_tokens) > 6)
@@ -158,11 +162,11 @@ Dl::generate_cache(PkBackendJob *job, const gchar *tmpl) noexcept
} }
else else
{ {
skip = TRUE; /* Skip other candidates for collections */ skip = true; /* Skip other candidates for collections */
} }
if (skip) if (skip)
{ {
skip = FALSE; skip = false;
} }
else else
{ {
@@ -186,15 +190,15 @@ Dl::generate_cache(PkBackendJob *job, const gchar *tmpl) noexcept
} }
/* Create a collection entry */ /* Create a collection entry */
if (collection_name && g_seekable_seek(G_SEEKABLE(data_in), 0, G_SEEK_SET, NULL, NULL) if (collection_name && g_seekable_seek(G_SEEKABLE(data_in), 0, G_SEEK_SET, nullptr, nullptr)
&& (sqlite3_prepare_v2(job_data->db, && (sqlite3_prepare_v2(job_data->db,
"INSERT INTO collections (name, repo_order, collection_pkg) " "INSERT INTO collections (name, repo_order, collection_pkg) "
"VALUES (@name, @repo_order, @collection_pkg)", "VALUES (@name, @repo_order, @collection_pkg)",
-1, -1,
&stmt, &stmt,
NULL) == SQLITE_OK)) nullptr) == SQLITE_OK))
{ {
while ((line = g_data_input_stream_read_line(data_in, NULL, NULL, NULL))) while ((line = g_data_input_stream_read_line(data_in, nullptr, nullptr, nullptr)))
{ {
line_tokens = g_strsplit(line, ":", 0); line_tokens = g_strsplit(line, ":", 0);
if ((g_strv_length(line_tokens) > 6) if ((g_strv_length(line_tokens) > 6)
@@ -221,7 +225,7 @@ Dl::generate_cache(PkBackendJob *job, const gchar *tmpl) noexcept
} }
g_free(collection_name); g_free(collection_name);
sqlite3_exec(job_data->db, "END TRANSACTION", NULL, NULL, NULL); sqlite3_exec(job_data->db, "END TRANSACTION", nullptr, nullptr, nullptr);
out: out:
if (data_in) if (data_in)
@@ -260,19 +264,19 @@ Dl::~Dl () noexcept
* *
* Return value: New #slack::Dl. * Return value: New #slack::Dl.
**/ **/
Dl::Dl (const gchar *name, const gchar *mirror, Dl::Dl (const char *name, const char *mirror,
guint8 order, const gchar *blacklist, gchar *index_file) noexcept std::uint8_t order, const char *blacklist, char *index_file) noexcept
{ {
GRegex *regex; GRegex *regex;
if (blacklist) if (blacklist)
{ {
regex = static_cast<GRegex *> (g_regex_new (blacklist, regex = static_cast<GRegex *> (g_regex_new (blacklist,
G_REGEX_OPTIMIZE, static_cast<GRegexMatchFlags> (0), NULL)); G_REGEX_OPTIMIZE, static_cast<GRegexMatchFlags> (0), nullptr));
} }
else else
{ {
regex = NULL; regex = nullptr;
} }
this->name = g_strdup (name); this->name = g_strdup (name);

22
backend/dl.h
View File

@@ -1,24 +1,28 @@
#ifndef __SLACK_DL_H /*
#define __SLACK_DL_H * 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 <cstdint>
#include "pkgtools.h" #include "pkgtools.h"
#include "utils.h"
namespace slack { namespace slack {
class Dl final : public Pkgtools class Dl final : public Pkgtools
{ {
public: public:
Dl (const gchar *name, const gchar *mirror, Dl (const char *name, const char *mirror,
guint8 order, const gchar *blacklist, gchar *index_file) noexcept; std::uint8_t order, const char *blacklist, char *index_file) noexcept;
~Dl () noexcept; ~Dl () noexcept;
GSList *collect_cache_info (const gchar *tmpl) noexcept; GSList *collect_cache_info (const char *tmpl) noexcept;
void generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept; void generate_cache (JobData *job_data, const char *tmpl) noexcept;
private: private:
gchar *index_file; char *index_file;
}; };
} }
#endif /* __SLACK_DL_H */

25
backend/job.cc
View File

@@ -1,3 +1,8 @@
/*
* 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 "job.h" #include "job.h"
#include <string> #include <string>
@@ -51,42 +56,42 @@ generate_query(PkBitfield filters)
} }
void void
pk_backend_search_thread (PkBackendJob *job, GVariant *params, gpointer user_data) pk_backend_search_thread (PkBackendJob *job, GVariant *params, void *user_data)
{ {
auto job_data = reinterpret_cast<slack::JobData *> (pk_backend_job_get_user_data (job)); auto job_data = reinterpret_cast<slack::JobData *> (pk_backend_job_get_user_data (job));
pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY); pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
pk_backend_job_set_percentage (job, 0); pk_backend_job_set_percentage (job, 0);
gchar **vals; char **vals;
PkBitfield filters; PkBitfield filters;
g_variant_get (params, "(t^a&s)", &filters, &vals); g_variant_get (params, "(t^a&s)", &filters, &vals);
gchar *search = g_strjoinv ("%", vals); char *search = g_strjoinv ("%", vals);
gchar *query = sqlite3_mprintf (slack::generate_query(filters).c_str(), char *query = sqlite3_mprintf (slack::generate_query(filters).c_str(),
user_data, search); user_data, search);
sqlite3_stmt *stmt; sqlite3_stmt *stmt;
if ((sqlite3_prepare_v2 (job_data->db, query, -1, &stmt, NULL) == SQLITE_OK)) if ((sqlite3_prepare_v2 (job_data->db, query, -1, &stmt, nullptr) == SQLITE_OK))
{ {
/* Now we're ready to output all packages */ /* Now we're ready to output all packages */
while (sqlite3_step (stmt) == SQLITE_ROW) while (sqlite3_step (stmt) == SQLITE_ROW)
{ {
PkInfoEnum info = slack::is_installed ( PkInfoEnum info = slack::is_installed (
reinterpret_cast<const gchar *> (sqlite3_column_text (stmt, 2))); reinterpret_cast<const char *> (sqlite3_column_text (stmt, 2)));
if ((info == PK_INFO_ENUM_INSTALLED || info == PK_INFO_ENUM_UPDATING) if ((info == PK_INFO_ENUM_INSTALLED || info == PK_INFO_ENUM_UPDATING)
&& slack::filter_package (filters, true)) && slack::filter_package (filters, true))
{ {
pk_backend_job_package (job, PK_INFO_ENUM_INSTALLED, pk_backend_job_package (job, PK_INFO_ENUM_INSTALLED,
reinterpret_cast<const gchar *> (sqlite3_column_text (stmt, 0)), reinterpret_cast<const char *> (sqlite3_column_text (stmt, 0)),
reinterpret_cast<const gchar *> (sqlite3_column_text (stmt, 1))); reinterpret_cast<const char *> (sqlite3_column_text (stmt, 1)));
} }
else if (info == PK_INFO_ENUM_INSTALLING && slack::filter_package (filters, false)) else if (info == PK_INFO_ENUM_INSTALLING && slack::filter_package (filters, false))
{ {
pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE, pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE,
reinterpret_cast<const gchar *> (sqlite3_column_text (stmt, 0)), reinterpret_cast<const char *> (sqlite3_column_text (stmt, 0)),
reinterpret_cast<const gchar *> (sqlite3_column_text (stmt, 1))); reinterpret_cast<const char *> (sqlite3_column_text (stmt, 1)));
} }
} }
sqlite3_finalize (stmt); sqlite3_finalize (stmt);

12
backend/job.h
View File

@@ -1,5 +1,9 @@
#ifndef __SLACK_JOB_H /*
#define __SLACK_JOB_H * 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 <pk-backend.h> #include <pk-backend.h>
#include <sqlite3.h> #include <sqlite3.h>
@@ -12,8 +16,6 @@ bool filter_package (PkBitfield filters, bool is_installed);
extern "C" { extern "C" {
void pk_backend_search_thread (PkBackendJob *job, GVariant *params, gpointer user_data); void pk_backend_search_thread (PkBackendJob *job, GVariant *params, void *user_data);
} }
#endif /* __SLACK_JOB_H */

53
backend/meson.build
View File

@@ -1,53 +0,0 @@
add_languages('cpp', native: false)
curl_dep = meson.get_compiler('c').find_library('curl')
bzip2_dep = dependency('bzip2')
packagekit_backend_slack_module = shared_module(
'pk_backend_slack',
'pk-backend-slack.cc',
'utils.cc',
'pkgtools.cc',
'slackpkg.cc',
'dl.cc',
'job.cc',
include_directories: packagekit_src_include,
dependencies: [
packagekit_glib2_dep,
curl_dep,
gmodule_dep,
sqlite3_dep,
bzip2_dep,
],
cpp_args: [
'-DG_LOG_DOMAIN="PackageKit-Slackware"',
'-DLOCALSTATEDIR="@0@"'.format(join_paths(get_option('prefix'), get_option('localstatedir'))),
'-DLIBDIR="@0@"'.format(join_paths(get_option('prefix'), get_option('libdir'))),
'-DSYSCONFDIR="@0@"'.format(get_option('sysconfdir')),
],
override_options: ['c_std=c14', 'cpp_std=c++14'],
install: true,
install_dir: pk_plugin_dir,
)
subdir('tests')
slackware_config_data = configuration_data()
if (target_machine.cpu_family() == 'x86_64')
slackware_config_data.set('pkgmain', 'slackware64')
else
slackware_config_data.set('pkgmain', 'slackware')
endif
configure_file(
input: 'Slackware.conf.in',
output: 'Slackware.conf',
configuration: slackware_config_data,
install: true,
install_dir: join_paths(get_option('sysconfdir'), 'PackageKit'),
)
install_data(
'metadata.db',
install_dir: join_paths(get_option('localstatedir'), 'cache', 'PackageKit', 'metadata'),
)

397
backend/pk-backend-slack.cc
View File

@@ -1,6 +1,12 @@
/*
* 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 <dirent.h> #include <dirent.h>
#include <glib/gstdio.h> #include <glib/gstdio.h>
#include <packagekit-glib2/pk-debug.h> #include <packagekit-glib2/pk-debug.h>
#include <cstdint>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <zlib.h> #include <zlib.h>
@@ -15,19 +21,19 @@
using namespace slack; using namespace slack;
static GSList *repos = NULL; static GSList *repos = nullptr;
void pk_backend_initialize(GKeyFile *conf, PkBackend *backend) void pk_backend_initialize(GKeyFile *conf, PkBackend *backend)
{ {
gchar *path, **groups; char *path, **groups;
gint ret; int ret;
gushort i; gushort i;
gsize groups_len; gsize groups_len;
GFile *conf_file; GFile *conf_file;
GFileInfo *file_info; GFileInfo *file_info;
GKeyFile *key_conf; GKeyFile *key_conf;
GError *err = NULL; GError *err = nullptr;
gpointer repo = NULL; void *repo = nullptr;
sqlite3 *db; sqlite3 *db;
sqlite3_stmt *stmt; sqlite3_stmt *stmt;
@@ -35,7 +41,7 @@ void pk_backend_initialize(GKeyFile *conf, PkBackend *backend)
curl_global_init(CURL_GLOBAL_DEFAULT); curl_global_init(CURL_GLOBAL_DEFAULT);
/* Open the database. We will need it to save the time the configuration file was last modified. */ /* 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", NULL); path = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", nullptr);
if (sqlite3_open(path, &db) != SQLITE_OK) if (sqlite3_open(path, &db) != SQLITE_OK)
{ {
g_error("%s: %s", path, sqlite3_errmsg(db)); g_error("%s: %s", path, sqlite3_errmsg(db));
@@ -44,7 +50,7 @@ void pk_backend_initialize(GKeyFile *conf, PkBackend *backend)
/* Read the configuration file */ /* Read the configuration file */
key_conf = g_key_file_new(); key_conf = g_key_file_new();
path = g_build_filename(SYSCONFDIR, "PackageKit", "Slackware.conf", NULL); path = g_build_filename(SYSCONFDIR, "PackageKit", "Slackware.conf", nullptr);
g_key_file_load_from_file(key_conf, path, G_KEY_FILE_NONE, &err); g_key_file_load_from_file(key_conf, path, G_KEY_FILE_NONE, &err);
if (err) if (err)
{ {
@@ -56,7 +62,7 @@ void pk_backend_initialize(GKeyFile *conf, PkBackend *backend)
if (!(file_info = g_file_query_info(conf_file, if (!(file_info = g_file_query_info(conf_file,
"time::modified-usec", "time::modified-usec",
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL, nullptr,
&err))) &err)))
{ {
g_error("%s", err->message); g_error("%s", err->message);
@@ -67,7 +73,7 @@ void pk_backend_initialize(GKeyFile *conf, PkBackend *backend)
"UPDATE cache_info SET value = ? WHERE key LIKE 'last_modification'", "UPDATE cache_info SET value = ? WHERE key LIKE 'last_modification'",
-1, -1,
&stmt, &stmt,
NULL)) == SQLITE_OK) { nullptr)) == SQLITE_OK) {
ret = sqlite3_bind_int(stmt, 1, g_file_info_get_attribute_uint32(file_info, "time::modified-usec")); ret = sqlite3_bind_int(stmt, 1, g_file_info_get_attribute_uint32(file_info, "time::modified-usec"));
if (ret == SQLITE_OK) if (ret == SQLITE_OK)
{ {
@@ -93,18 +99,18 @@ void pk_backend_initialize(GKeyFile *conf, PkBackend *backend)
groups = g_key_file_get_groups(key_conf, &groups_len); groups = g_key_file_get_groups(key_conf, &groups_len);
for (i = 0; i < groups_len; i++) for (i = 0; i < groups_len; i++)
{ {
gchar *blacklist = g_key_file_get_string(key_conf, groups[i], "Blacklist", NULL); char *blacklist = g_key_file_get_string(key_conf, groups[i], "Blacklist", nullptr);
gchar *mirror = g_key_file_get_string(key_conf, groups[i], "Mirror", NULL); char *mirror = g_key_file_get_string(key_conf, groups[i], "Mirror", nullptr);
if (g_key_file_has_key(key_conf, groups[i], "Priority", NULL)) if (g_key_file_has_key(key_conf, groups[i], "Priority", nullptr))
{ {
repo = new Slackpkg (groups[i], mirror, i + 1, blacklist, repo = new Slackpkg (groups[i], mirror, i + 1, blacklist,
g_key_file_get_string_list(key_conf, groups[i], "Priority", NULL, NULL)); 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", NULL)) else if (g_key_file_has_key(key_conf, groups[i], "IndexFile", nullptr))
{ {
repo = new Dl (groups[i], mirror, i + 1, blacklist, repo = new Dl (groups[i], mirror, i + 1, blacklist,
g_key_file_get_string(key_conf, groups[i], "IndexFile", NULL)); g_key_file_get_string(key_conf, groups[i], "IndexFile", nullptr));
} }
if (repo) if (repo)
@@ -137,71 +143,18 @@ pk_backend_destroy(PkBackend *backend)
curl_global_cleanup (); curl_global_cleanup ();
} }
gchar **
pk_backend_get_mime_types(PkBackend *backend)
{
const gchar *mime_types[] = {
"application/x-xz-compressed-tar",
"application/x-compressed-tar",
"application/x-bzip-compressed-tar",
"application/x-lzma-compressed-tar",
NULL
};
return g_strdupv((gchar **) mime_types);
}
gboolean
pk_backend_supports_parallelization(PkBackend *backend)
{
return FALSE;
}
const gchar *
pk_backend_get_description(PkBackend* backend)
{
return "Slackware";
}
const gchar *
pk_backend_get_author(PkBackend* backend)
{
return "Eugene Wissner <belka@caraus.de>";
}
PkBitfield
pk_backend_get_groups(PkBackend *backend)
{
return pk_bitfield_from_enums(PK_GROUP_ENUM_COLLECTIONS,
PK_GROUP_ENUM_SYSTEM,
PK_GROUP_ENUM_ADMIN_TOOLS,
PK_GROUP_ENUM_PROGRAMMING,
PK_GROUP_ENUM_PUBLISHING,
PK_GROUP_ENUM_DOCUMENTATION,
PK_GROUP_ENUM_DESKTOP_KDE,
PK_GROUP_ENUM_LOCALIZATION,
PK_GROUP_ENUM_NETWORK,
PK_GROUP_ENUM_DESKTOP_OTHER,
PK_GROUP_ENUM_ACCESSORIES,
PK_GROUP_ENUM_DESKTOP_XFCE,
PK_GROUP_ENUM_GAMES,
PK_GROUP_ENUM_OTHER,
PK_GROUP_ENUM_UNKNOWN,
-1);
}
void void
pk_backend_start_job(PkBackend *backend, PkBackendJob *job) pk_backend_start_job(PkBackend *backend, PkBackendJob *job)
{ {
gchar *db_filename = NULL; char *db_filename = nullptr;
JobData *job_data = g_new0(JobData, 1); JobData *job_data = g_new0(JobData, 1);
pk_backend_job_set_allow_cancel(job, TRUE); pk_backend_job_set_allow_cancel(job, true);
pk_backend_job_set_allow_cancel(job, FALSE); pk_backend_job_set_allow_cancel(job, false);
db_filename = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", NULL); 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 */ if (sqlite3_open(db_filename, &job_data->db) == SQLITE_OK) { /* Some SQLite settings */
sqlite3_exec(job_data->db, "PRAGMA foreign_keys = ON", NULL, NULL, NULL); sqlite3_exec(job_data->db, "PRAGMA foreign_keys = ON", nullptr, nullptr, nullptr);
} }
else else
{ {
@@ -231,32 +184,32 @@ pk_backend_stop_job(PkBackend *backend, PkBackendJob *job)
sqlite3_close(job_data->db); sqlite3_close(job_data->db);
g_free(job_data); g_free(job_data);
pk_backend_job_set_user_data(job, NULL); pk_backend_job_set_user_data(job, nullptr);
} }
void void
pk_backend_search_names(PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **values) pk_backend_search_names(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **values)
{ {
pk_backend_job_thread_create(job, pk_backend_search_thread, (gpointer) "name", NULL); pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "name", nullptr);
} }
void void
pk_backend_search_details(PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **values) pk_backend_search_details(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **values)
{ {
pk_backend_job_thread_create(job, pk_backend_search_thread, (gpointer) "desc", NULL); pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "desc", nullptr);
} }
void void
pk_backend_search_groups(PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **values) pk_backend_search_groups(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **values)
{ {
pk_backend_job_thread_create(job, pk_backend_search_thread, (gpointer) "cat", NULL); pk_backend_job_thread_create(job, pk_backend_search_thread, (void *) "cat", nullptr);
} }
static void static void
pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, gpointer user_data) pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, void *user_data)
{ {
gchar **vals, *search; char **vals, *search;
gchar *query; char *query;
sqlite3_stmt *stmt; sqlite3_stmt *stmt;
PkInfoEnum ret; PkInfoEnum ret;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
@@ -264,30 +217,30 @@ pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, gpointer use
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY); pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
pk_backend_job_set_percentage(job, 0); pk_backend_job_set_percentage(job, 0);
g_variant_get(params, "(t^a&s)", NULL, &vals); g_variant_get(params, "(t^a&s)", nullptr, &vals);
search = g_strjoinv("%", vals); search = g_strjoinv("%", vals);
query = sqlite3_mprintf("SELECT (p.name || ';' || p.ver || ';' || p.arch || ';' || r.repo), p.summary, " 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 " "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); "WHERE f.filename LIKE '%%%q%%' GROUP BY f.full_name", search);
if ((sqlite3_prepare_v2(job_data->db, query, -1, &stmt, NULL) == SQLITE_OK)) if ((sqlite3_prepare_v2(job_data->db, query, -1, &stmt, nullptr) == SQLITE_OK))
{ {
/* Now we're ready to output all packages */ /* Now we're ready to output all packages */
while (sqlite3_step(stmt) == SQLITE_ROW) while (sqlite3_step(stmt) == SQLITE_ROW)
{ {
ret = is_installed((gchar*) sqlite3_column_text(stmt, 2)); ret = is_installed((char*) sqlite3_column_text(stmt, 2));
if ((ret == PK_INFO_ENUM_INSTALLED) || (ret == PK_INFO_ENUM_UPDATING)) if ((ret == PK_INFO_ENUM_INSTALLED) || (ret == PK_INFO_ENUM_UPDATING))
{ {
pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED, pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED,
(gchar*) sqlite3_column_text(stmt, 0), (char*) sqlite3_column_text(stmt, 0),
(gchar*) sqlite3_column_text(stmt, 1)); (char*) sqlite3_column_text(stmt, 1));
} }
else if (ret == PK_INFO_ENUM_INSTALLING) else if (ret == PK_INFO_ENUM_INSTALLING)
{ {
pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE, pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE,
(gchar*) sqlite3_column_text(stmt, 0), (char*) sqlite3_column_text(stmt, 0),
(gchar*) sqlite3_column_text(stmt, 1)); (char*) sqlite3_column_text(stmt, 1));
} }
} }
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
@@ -303,21 +256,21 @@ pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, gpointer use
} }
void void
pk_backend_search_files(PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **values) pk_backend_search_files(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **values)
{ {
pk_backend_job_thread_create(job, pk_backend_search_files_thread, NULL, NULL); pk_backend_job_thread_create(job, pk_backend_search_files_thread, nullptr, nullptr);
} }
static void static void
pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, gpointer user_data) pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, void *user_data)
{ {
gchar **pkg_ids, *homepage = NULL; char **pkg_ids, *homepage = nullptr;
gchar** tokens; char** tokens;
gsize i; gsize i;
GString *desc; GString *desc;
GRegex *expr; GRegex *expr;
GMatchInfo *match_info; GMatchInfo *match_info;
GError *err = NULL; GError *err = nullptr;
sqlite3_stmt *stmt; sqlite3_stmt *stmt;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
@@ -330,7 +283,7 @@ pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, gpointer user
"WHERE name LIKE @name AND r.repo LIKE @repo AND ext NOT LIKE 'obsolete'", "WHERE name LIKE @name AND r.repo LIKE @repo AND ext NOT LIKE 'obsolete'",
-1, -1,
&stmt, &stmt,
NULL) != SQLITE_OK)) { nullptr) != SQLITE_OK)) {
pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db)); pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
goto out; goto out;
} }
@@ -343,7 +296,7 @@ pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, gpointer user
if (sqlite3_step(stmt) != SQLITE_ROW) if (sqlite3_step(stmt) != SQLITE_ROW)
goto out; goto out;
desc = g_string_new((gchar *) sqlite3_column_text(stmt, 0)); desc = g_string_new((char *) sqlite3_column_text(stmt, 0));
/* Regular expression for searching a homepage */ /* Regular expression for searching a homepage */
expr = g_regex_new("(?:http|ftp):\\/\\/[[:word:]\\/\\-\\.]+[[:word:]\\/](?=\\.?$)", expr = g_regex_new("(?:http|ftp):\\/\\/[[:word:]\\/\\-\\.]+[[:word:]\\/](?=\\.?$)",
@@ -375,9 +328,9 @@ pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, gpointer user
/* Ready */ /* Ready */
pk_backend_job_details(job, pk_backend_job_details(job,
pkg_ids[0], pkg_ids[0],
NULL, nullptr,
NULL, nullptr,
pk_group_enum_from_string((gchar *) sqlite3_column_text(stmt, 1)), pk_group_enum_from_string((char *) sqlite3_column_text(stmt, 1)),
desc->str, desc->str,
homepage, homepage,
sqlite3_column_int(stmt, 2), sqlite3_column_int(stmt, 2),
@@ -386,7 +339,7 @@ pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, gpointer user
g_free(homepage); g_free(homepage);
if (desc) if (desc)
{ {
g_string_free(desc, TRUE); g_string_free(desc, true);
} }
out: out:
@@ -394,15 +347,15 @@ out:
} }
void void
pk_backend_get_details(PkBackend *backend, PkBackendJob *job, gchar **package_ids) pk_backend_get_details(PkBackend *backend, PkBackendJob *job, char **package_ids)
{ {
pk_backend_job_thread_create(job, pk_backend_get_details_thread, NULL, NULL); pk_backend_job_thread_create(job, pk_backend_get_details_thread, nullptr, nullptr);
} }
static void static void
pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, gpointer user_data) pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, void *user_data)
{ {
gchar **vals, **val; char **vals, **val;
sqlite3_stmt *stmt; sqlite3_stmt *stmt;
PkInfoEnum ret; PkInfoEnum ret;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
@@ -410,7 +363,7 @@ pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, gpointer user_dat
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY); pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
pk_backend_job_set_percentage(job, 0); pk_backend_job_set_percentage(job, 0);
g_variant_get(params, "(t^a&s)", NULL, &vals); g_variant_get(params, "(t^a&s)", nullptr, &vals);
if ((sqlite3_prepare_v2(job_data->db, if ((sqlite3_prepare_v2(job_data->db,
"SELECT (p1.name || ';' || p1.ver || ';' || p1.arch || ';' || r.repo), p1.summary, " "SELECT (p1.name || ';' || p1.ver || ';' || p1.arch || ';' || r.repo), p1.summary, "
@@ -419,7 +372,7 @@ pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, gpointer user_dat
"(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)", "(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)",
-1, -1,
&stmt, &stmt,
NULL) == SQLITE_OK)) { nullptr) == SQLITE_OK)) {
/* Output packages matching each pattern */ /* Output packages matching each pattern */
for (val = vals; *val; val++) for (val = vals; *val; val++)
{ {
@@ -427,18 +380,18 @@ pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, gpointer user_dat
while (sqlite3_step(stmt) == SQLITE_ROW) while (sqlite3_step(stmt) == SQLITE_ROW)
{ {
ret = is_installed((gchar*) sqlite3_column_text(stmt, 2)); ret = is_installed((char*) sqlite3_column_text(stmt, 2));
if ((ret == PK_INFO_ENUM_INSTALLED) || (ret == PK_INFO_ENUM_UPDATING)) if ((ret == PK_INFO_ENUM_INSTALLED) || (ret == PK_INFO_ENUM_UPDATING))
{ {
pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED, pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED,
(gchar*) sqlite3_column_text(stmt, 0), (char*) sqlite3_column_text(stmt, 0),
(gchar*) sqlite3_column_text(stmt, 1)); (char*) sqlite3_column_text(stmt, 1));
} }
else if (ret == PK_INFO_ENUM_INSTALLING) else if (ret == PK_INFO_ENUM_INSTALLING)
{ {
pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE, pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE,
(gchar*) sqlite3_column_text(stmt, 0), (char*) sqlite3_column_text(stmt, 0),
(gchar*) sqlite3_column_text(stmt, 1)); (char*) sqlite3_column_text(stmt, 1));
} }
} }
@@ -454,16 +407,16 @@ pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, gpointer user_dat
} }
void void
pk_backend_resolve(PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **packages) pk_backend_resolve(PkBackend *backend, PkBackendJob *job, PkBitfield filters, char **packages)
{ {
pk_backend_job_thread_create(job, pk_backend_resolve_thread, NULL, NULL); pk_backend_job_thread_create(job, pk_backend_resolve_thread, nullptr, nullptr);
} }
static void static void
pk_backend_download_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data) pk_backend_download_packages_thread(PkBackendJob *job, GVariant *params, void *user_data)
{ {
gchar *dir_path, *path, **pkg_ids, *to_strv[] = {NULL, NULL}; char *dir_path, *path, **pkg_ids, *to_strv[] = {nullptr, nullptr};
guint i; unsigned i;
sqlite3_stmt *stmt; sqlite3_stmt *stmt;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
@@ -475,7 +428,7 @@ pk_backend_download_packages_thread(PkBackendJob *job, GVariant *params, gpointe
"WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo", "WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo",
-1, -1,
&stmt, &stmt,
NULL) != SQLITE_OK)) nullptr) != SQLITE_OK))
{ {
pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db)); pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
goto out; goto out;
@@ -483,7 +436,7 @@ pk_backend_download_packages_thread(PkBackendJob *job, GVariant *params, gpointe
for (i = 0; pkg_ids[i]; ++i) for (i = 0; pkg_ids[i]; ++i)
{ {
gchar **tokens = pk_package_id_split(pkg_ids[i]); char **tokens = pk_package_id_split(pkg_ids[i]);
sqlite3_bind_text(stmt, 1, tokens[PK_PACKAGE_ID_NAME], -1, SQLITE_TRANSIENT); 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, 2, tokens[PK_PACKAGE_ID_VERSION], -1, SQLITE_TRANSIENT);
@@ -496,12 +449,12 @@ pk_backend_download_packages_thread(PkBackendJob *job, GVariant *params, gpointe
{ {
pk_backend_job_package(job, PK_INFO_ENUM_DOWNLOADING, pk_backend_job_package(job, PK_INFO_ENUM_DOWNLOADING,
pkg_ids[i], pkg_ids[i],
(gchar *) sqlite3_column_text(stmt, 0)); (char *) sqlite3_column_text(stmt, 0));
static_cast<Pkgtools *> (repo->data)->download (job, static_cast<Pkgtools *> (repo->data)->download (job,
dir_path, tokens[PK_PACKAGE_ID_NAME]); dir_path, tokens[PK_PACKAGE_ID_NAME]);
path = g_build_filename(dir_path, (gchar *) sqlite3_column_text(stmt, 1), NULL); path = g_build_filename(dir_path, (char *) sqlite3_column_text(stmt, 1), nullptr);
to_strv[0] = path; to_strv[0] = path;
pk_backend_job_files(job, NULL, to_strv); pk_backend_job_files(job, nullptr, to_strv);
g_free(path); g_free(path);
} }
} }
@@ -515,20 +468,20 @@ out:
} }
void void
pk_backend_download_packages(PkBackend *backend, PkBackendJob *job, gchar **package_ids, const gchar *directory) pk_backend_download_packages(PkBackend *backend, PkBackendJob *job, char **package_ids, const char *directory)
{ {
pk_backend_job_thread_create(job, pk_backend_download_packages_thread, NULL, NULL); pk_backend_job_thread_create(job, pk_backend_download_packages_thread, nullptr, nullptr);
} }
static void static void
pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data) pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, void *user_data)
{ {
gchar *dest_dir_name; char *dest_dir_name;
gchar **pkg_ids; char **pkg_ids;
guint i; unsigned i;
gdouble percent_step; gdouble percent_step;
GSList *install_list = NULL, *l; GSList *install_list = nullptr, *l;
sqlite3_stmt *pkglist_stmt = NULL, *collection_stmt = NULL; sqlite3_stmt *pkglist_stmt = nullptr, *collection_stmt = nullptr;
PkBitfield transaction_flags = 0; PkBitfield transaction_flags = 0;
PkInfoEnum ret; PkInfoEnum ret;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
@@ -541,7 +494,7 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, gpointer
"WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo", "WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo",
-1, -1,
&pkglist_stmt, &pkglist_stmt,
NULL) != SQLITE_OK) || nullptr) != SQLITE_OK) ||
(sqlite3_prepare_v2(job_data->db, (sqlite3_prepare_v2(job_data->db,
"SELECT (c.collection_pkg || ';' || p.ver || ';' || p.arch || ';' || r.repo), p.summary, " "SELECT (c.collection_pkg || ';' || p.ver || ';' || p.arch || ';' || r.repo), p.summary, "
"p.full_name, p.ext FROM collections AS c " "p.full_name, p.ext FROM collections AS c "
@@ -550,7 +503,7 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, gpointer
"WHERE c.name LIKE @name AND r.repo LIKE @repo", "WHERE c.name LIKE @name AND r.repo LIKE @repo",
-1, -1,
&collection_stmt, &collection_stmt,
NULL) != SQLITE_OK)) nullptr) != SQLITE_OK))
{ {
pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db)); pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
goto out; goto out;
@@ -558,7 +511,7 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, gpointer
for (i = 0; pkg_ids[i]; i++) for (i = 0; pkg_ids[i]; i++)
{ {
gchar **tokens = pk_package_id_split(pkg_ids[i]); char **tokens = pk_package_id_split(pkg_ids[i]);
sqlite3_bind_text(pkglist_stmt, 1, tokens[PK_PACKAGE_ID_NAME], -1, SQLITE_TRANSIENT); 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, 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, 3, tokens[PK_PACKAGE_ID_ARCH], -1, SQLITE_TRANSIENT);
@@ -567,13 +520,13 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, gpointer
if (sqlite3_step(pkglist_stmt) == SQLITE_ROW) if (sqlite3_step(pkglist_stmt) == SQLITE_ROW)
{ {
/* If it isn't a collection */ /* If it isn't a collection */
if (g_strcmp0((gchar *) sqlite3_column_text(pkglist_stmt, 1), "collections")) if (g_strcmp0((char *) sqlite3_column_text(pkglist_stmt, 1), "collections"))
{ {
if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE))
{ {
pk_backend_job_package(job, PK_INFO_ENUM_INSTALLING, pk_backend_job_package(job, PK_INFO_ENUM_INSTALLING,
pkg_ids[i], pkg_ids[i],
(gchar *) sqlite3_column_text(pkglist_stmt, 0)); (char *) sqlite3_column_text(pkglist_stmt, 0));
} }
else else
{ {
@@ -587,24 +540,24 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, gpointer
while (sqlite3_step(collection_stmt) == SQLITE_ROW) while (sqlite3_step(collection_stmt) == SQLITE_ROW)
{ {
ret = is_installed((gchar*) sqlite3_column_text(collection_stmt, 2)); ret = is_installed((char*) sqlite3_column_text(collection_stmt, 2));
if ((ret == PK_INFO_ENUM_INSTALLING) || (ret == PK_INFO_ENUM_UPDATING)) if ((ret == PK_INFO_ENUM_INSTALLING) || (ret == PK_INFO_ENUM_UPDATING))
{ {
if ((pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) && if ((pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) &&
!g_strcmp0((gchar *) sqlite3_column_text(collection_stmt, 3), "obsolete")) !g_strcmp0((char *) sqlite3_column_text(collection_stmt, 3), "obsolete"))
{ {
/* TODO: Don't just skip obsolete packages but remove them */ /* TODO: Don't just skip obsolete packages but remove them */
} }
else if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) else if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE))
{ {
pk_backend_job_package(job, ret, pk_backend_job_package(job, ret,
(gchar *) sqlite3_column_text(collection_stmt, 0), (char *) sqlite3_column_text(collection_stmt, 0),
(gchar *) sqlite3_column_text(collection_stmt, 1)); (char *) sqlite3_column_text(collection_stmt, 1));
} }
else else
{ {
install_list = g_slist_append(install_list, install_list = g_slist_append(install_list,
g_strdup((gchar *) sqlite3_column_text(collection_stmt, 0))); g_strdup((char *) sqlite3_column_text(collection_stmt, 0)));
} }
} }
} }
@@ -625,14 +578,14 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, gpointer
/* Download the packages */ /* Download the packages */
pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD); pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD);
dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", NULL); dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", nullptr);
for (l = install_list, i = 0; l; l = g_slist_next(l), i++) for (l = install_list, i = 0; l; l = g_slist_next(l), i++)
{ {
gchar **tokens; char **tokens;
GSList *repo; GSList *repo;
pk_backend_job_set_percentage(job, percent_step * i); pk_backend_job_set_percentage(job, percent_step * i);
tokens = pk_package_id_split((gchar *)(l->data)); tokens = pk_package_id_split((char *)(l->data));
repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo); repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo);
if (repo) if (repo)
@@ -648,11 +601,11 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, gpointer
pk_backend_job_set_status(job, PK_STATUS_ENUM_INSTALL); pk_backend_job_set_status(job, PK_STATUS_ENUM_INSTALL);
for (l = install_list; l; l = g_slist_next(l), i++) for (l = install_list; l; l = g_slist_next(l), i++)
{ {
gchar **tokens; char **tokens;
GSList *repo; GSList *repo;
pk_backend_job_set_percentage(job, percent_step * i); pk_backend_job_set_percentage(job, percent_step * i);
tokens = pk_package_id_split((gchar *)(l->data)); tokens = pk_package_id_split((char *)(l->data));
repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo); repo = g_slist_find_custom(repos, tokens[PK_PACKAGE_ID_DATA], cmp_repo);
if (repo) if (repo)
@@ -673,19 +626,19 @@ void
pk_backend_install_packages(PkBackend *backend, pk_backend_install_packages(PkBackend *backend,
PkBackendJob *job, PkBackendJob *job,
PkBitfield transaction_flags, PkBitfield transaction_flags,
gchar **package_ids) char **package_ids)
{ {
pk_backend_job_thread_create(job, pk_backend_install_packages_thread, NULL, NULL); pk_backend_job_thread_create(job, pk_backend_install_packages_thread, nullptr, nullptr);
} }
static void static void
pk_backend_remove_packages_thread(PkBackendJob* job, GVariant* params, gpointer user_data) pk_backend_remove_packages_thread(PkBackendJob* job, GVariant* params, void *user_data)
{ {
gchar **pkg_ids, *cmd_line; char **pkg_ids, *cmd_line;
guint i; unsigned i;
gdouble percent_step; gdouble percent_step;
gboolean allow_deps, autoremove; bool allow_deps, autoremove;
GError *err = NULL; GError *err = nullptr;
PkBitfield transaction_flags = 0; PkBitfield transaction_flags = 0;
g_variant_get(params, "(t^a&sbb)", &transaction_flags, &pkg_ids, &allow_deps, &autoremove); g_variant_get(params, "(t^a&sbb)", &transaction_flags, &pkg_ids, &allow_deps, &autoremove);
@@ -702,14 +655,14 @@ pk_backend_remove_packages_thread(PkBackendJob* job, GVariant* params, gpointer
percent_step = 100.0 / g_strv_length(pkg_ids); percent_step = 100.0 / g_strv_length(pkg_ids);
for (i = 0; pkg_ids[i]; i++) for (i = 0; pkg_ids[i]; i++)
{ {
gchar **tokens; char **tokens;
pk_backend_job_set_percentage(job, percent_step * i); pk_backend_job_set_percentage(job, percent_step * i);
tokens = pk_package_id_split(pkg_ids[i]); tokens = pk_package_id_split(pkg_ids[i]);
cmd_line = g_strconcat("/sbin/removepkg ", tokens[PK_PACKAGE_ID_NAME], NULL); cmd_line = g_strconcat("/sbin/removepkg ", tokens[PK_PACKAGE_ID_NAME], nullptr);
/* Pkgtools return always 0 */ /* Pkgtools return always 0 */
g_spawn_command_line_sync(cmd_line, NULL, NULL, NULL, &err); g_spawn_command_line_sync(cmd_line, nullptr, nullptr, nullptr, &err);
g_free(cmd_line); g_free(cmd_line);
g_strfreev(tokens); g_strfreev(tokens);
@@ -731,22 +684,22 @@ void
pk_backend_remove_packages(PkBackend *backend, pk_backend_remove_packages(PkBackend *backend,
PkBackendJob *job, PkBackendJob *job,
PkBitfield transaction_flags, PkBitfield transaction_flags,
gchar **package_ids, char **package_ids,
gboolean allow_deps, bool allow_deps,
gboolean autoremove) bool autoremove)
{ {
pk_backend_job_thread_create(job, pk_backend_remove_packages_thread, NULL, NULL); pk_backend_job_thread_create(job, pk_backend_remove_packages_thread, nullptr, nullptr);
} }
static void static void
pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user_data) pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, void *user_data)
{ {
gchar *pkg_id, *full_name, *desc; char *pkg_id, *full_name, *desc;
const gchar *pkg_metadata_filename; const char *pkg_metadata_filename;
GFile *pkg_metadata_dir; GFile *pkg_metadata_dir;
GFileEnumerator *pkg_metadata_enumerator; GFileEnumerator *pkg_metadata_enumerator;
GFileInfo *pkg_metadata_file_info; GFileInfo *pkg_metadata_file_info;
GError *err = NULL; GError *err = nullptr;
sqlite3_stmt *stmt; sqlite3_stmt *stmt;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
@@ -759,7 +712,7 @@ pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user
"(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)", "(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)",
-1, -1,
&stmt, &stmt,
NULL) != SQLITE_OK)) nullptr) != SQLITE_OK))
{ {
pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db)); pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
goto out; goto out;
@@ -769,7 +722,7 @@ pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user
pkg_metadata_dir = g_file_new_for_path("/var/log/packages"); pkg_metadata_dir = g_file_new_for_path("/var/log/packages");
pkg_metadata_enumerator = g_file_enumerate_children(pkg_metadata_dir, "standard::name", pkg_metadata_enumerator = g_file_enumerate_children(pkg_metadata_dir, "standard::name",
G_FILE_QUERY_INFO_NONE, G_FILE_QUERY_INFO_NONE,
NULL, nullptr,
&err); &err);
g_object_unref(pkg_metadata_dir); g_object_unref(pkg_metadata_dir);
if (err) if (err)
@@ -779,9 +732,9 @@ pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user
goto out; goto out;
} }
while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, NULL, NULL))) while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, nullptr, nullptr)))
{ {
gchar **tokens; char **tokens;
pkg_metadata_filename = g_file_info_get_name(pkg_metadata_file_info); pkg_metadata_filename = g_file_info_get_name(pkg_metadata_file_info);
tokens = split_package_name(pkg_metadata_filename); tokens = split_package_name(pkg_metadata_filename);
@@ -792,12 +745,12 @@ pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user
/* If there are more packages with the same name, remember the one from the /* If there are more packages with the same name, remember the one from the
* repository with the lowest order. */ * repository with the lowest order. */
if ((sqlite3_step(stmt) == SQLITE_ROW) if ((sqlite3_step(stmt) == SQLITE_ROW)
|| g_slist_find_custom(repos, ((gchar *) sqlite3_column_text(stmt, 4)), cmp_repo)) || g_slist_find_custom(repos, ((char *) sqlite3_column_text(stmt, 4)), cmp_repo))
{ {
full_name = g_strdup((gchar *) sqlite3_column_text(stmt, 0)); full_name = g_strdup((char *) sqlite3_column_text(stmt, 0));
if (!g_strcmp0((gchar *) sqlite3_column_text(stmt, 6), "obsolete")) if (!g_strcmp0((char *) sqlite3_column_text(stmt, 6), "obsolete"))
{ /* Remove if obsolete */ { /* Remove if obsolete */
pkg_id = pk_package_id_build(tokens[PK_PACKAGE_ID_NAME], pkg_id = pk_package_id_build(tokens[PK_PACKAGE_ID_NAME],
tokens[PK_PACKAGE_ID_VERSION], tokens[PK_PACKAGE_ID_VERSION],
@@ -807,7 +760,7 @@ pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user
* 1: Use the repository name instead of "obsolete" above and check in pk_backend_update_packages() * 1: Use the repository name instead of "obsolete" above and check in pk_backend_update_packages()
if the package is obsolete or not if the package is obsolete or not
* 2: Get description from /var/log/packages, not from the database */ * 2: Get description from /var/log/packages, not from the database */
desc = g_strdup((gchar *) sqlite3_column_text(stmt, 5)); 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, PK_INFO_ENUM_REMOVING, pkg_id, desc);
@@ -816,11 +769,11 @@ pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user
} }
else if (g_strcmp0(pkg_metadata_filename, full_name)) else if (g_strcmp0(pkg_metadata_filename, full_name))
{ /* Update available */ { /* Update available */
pkg_id = pk_package_id_build((gchar *) sqlite3_column_text(stmt, 1), pkg_id = pk_package_id_build((char *) sqlite3_column_text(stmt, 1),
(gchar *) sqlite3_column_text(stmt, 2), (char *) sqlite3_column_text(stmt, 2),
(gchar *) sqlite3_column_text(stmt, 3), (char *) sqlite3_column_text(stmt, 3),
(gchar *) sqlite3_column_text(stmt, 4)); (char *) sqlite3_column_text(stmt, 4));
desc = g_strdup((gchar *) sqlite3_column_text(stmt, 5)); desc = g_strdup((char *) sqlite3_column_text(stmt, 5));
pk_backend_job_package(job, PK_INFO_ENUM_NORMAL, pkg_id, desc); pk_backend_job_package(job, PK_INFO_ENUM_NORMAL, pkg_id, desc);
@@ -845,14 +798,14 @@ out:
void void
pk_backend_get_updates(PkBackend *backend, PkBackendJob *job, PkBitfield filters) pk_backend_get_updates(PkBackend *backend, PkBackendJob *job, PkBitfield filters)
{ {
pk_backend_job_thread_create(job, pk_backend_get_updates_thread, NULL, NULL); pk_backend_job_thread_create(job, pk_backend_get_updates_thread, nullptr, nullptr);
} }
static void static void
pk_backend_update_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data) pk_backend_update_packages_thread(PkBackendJob *job, GVariant *params, void *user_data)
{ {
gchar *dest_dir_name, *cmd_line, **pkg_ids; char *dest_dir_name, *cmd_line, **pkg_ids;
guint i; unsigned i;
PkBitfield transaction_flags = 0; PkBitfield transaction_flags = 0;
g_variant_get(params, "(t^a&s)", &transaction_flags, &pkg_ids); g_variant_get(params, "(t^a&s)", &transaction_flags, &pkg_ids);
@@ -861,10 +814,10 @@ pk_backend_update_packages_thread(PkBackendJob *job, GVariant *params, gpointer
pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD); pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD);
/* Download the packages */ /* Download the packages */
dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", NULL); dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", nullptr);
for (i = 0; pkg_ids[i]; i++) for (i = 0; pkg_ids[i]; i++)
{ {
gchar **tokens = pk_package_id_split(pkg_ids[i]); char **tokens = pk_package_id_split(pkg_ids[i]);
if (g_strcmp0(tokens[PK_PACKAGE_ID_DATA], "obsolete")) if (g_strcmp0(tokens[PK_PACKAGE_ID_DATA], "obsolete"))
{ {
@@ -885,7 +838,7 @@ pk_backend_update_packages_thread(PkBackendJob *job, GVariant *params, gpointer
pk_backend_job_set_status(job, PK_STATUS_ENUM_UPDATE); pk_backend_job_set_status(job, PK_STATUS_ENUM_UPDATE);
for (i = 0; pkg_ids[i]; i++) for (i = 0; pkg_ids[i]; i++)
{ {
gchar **tokens = pk_package_id_split(pkg_ids[i]); char **tokens = pk_package_id_split(pkg_ids[i]);
if (g_strcmp0(tokens[PK_PACKAGE_ID_DATA], "obsolete")) if (g_strcmp0(tokens[PK_PACKAGE_ID_DATA], "obsolete"))
{ {
@@ -901,8 +854,8 @@ pk_backend_update_packages_thread(PkBackendJob *job, GVariant *params, gpointer
{ {
/* Remove obsolete package /* Remove obsolete package
* TODO: Removing should be an independent operation (not during installing updates) */ * TODO: Removing should be an independent operation (not during installing updates) */
cmd_line = g_strconcat("/sbin/removepkg ", tokens[PK_PACKAGE_ID_NAME], NULL); cmd_line = g_strconcat("/sbin/removepkg ", tokens[PK_PACKAGE_ID_NAME], nullptr);
g_spawn_command_line_sync(cmd_line, NULL, NULL, NULL, NULL); g_spawn_command_line_sync(cmd_line, nullptr, nullptr, nullptr, nullptr);
g_free(cmd_line); g_free(cmd_line);
} }
g_strfreev(tokens); g_strfreev(tokens);
@@ -914,22 +867,22 @@ void
pk_backend_update_packages(PkBackend *backend, pk_backend_update_packages(PkBackend *backend,
PkBackendJob *job, PkBackendJob *job,
PkBitfield transaction_flags, PkBitfield transaction_flags,
gchar **package_ids) char **package_ids)
{ {
pk_backend_job_thread_create(job, pk_backend_update_packages_thread, NULL, NULL); pk_backend_job_thread_create(job, pk_backend_update_packages_thread, nullptr, nullptr);
} }
static void static void
pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, gpointer user_data) pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, void *user_data)
{ {
gchar *tmp_dir_name, *db_err, *path = NULL; char *tmp_dir_name, *db_err, *path = nullptr;
gint ret; int ret;
gboolean force; bool force;
GSList *file_list = NULL; GSList *file_list = nullptr;
GFile *db_file = NULL; GFile *db_file = nullptr;
GFileInfo *file_info = NULL; GFileInfo *file_info = nullptr;
GError *err = NULL; GError *err = nullptr;
sqlite3_stmt *stmt = NULL; sqlite3_stmt *stmt = nullptr;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD_CHANGELOG); pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD_CHANGELOG);
@@ -948,9 +901,9 @@ pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, gpointer us
/* Force the complete cache refresh if the read configuration file is newer than the metadata cache */ /* Force the complete cache refresh if the read configuration file is newer than the metadata cache */
if (!force) if (!force)
{ {
path = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", NULL); path = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", nullptr);
db_file = g_file_new_for_path(path); 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, NULL, &err); file_info = g_file_query_info(db_file, "time::modified-usec", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, nullptr, &err);
if (err) if (err)
{ {
pk_backend_job_error_code(job, PK_ERROR_ENUM_NO_CACHE, "%s: %s", path, err->message); pk_backend_job_error_code(job, PK_ERROR_ENUM_NO_CACHE, "%s: %s", path, err->message);
@@ -961,7 +914,7 @@ pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, gpointer us
"SELECT value FROM cache_info WHERE key LIKE 'last_modification'", "SELECT value FROM cache_info WHERE key LIKE 'last_modification'",
-1, -1,
&stmt, &stmt,
NULL); nullptr);
if ((ret != SQLITE_OK) || ((ret = sqlite3_step(stmt)) != SQLITE_ROW)) if ((ret != SQLITE_OK) || ((ret = sqlite3_step(stmt)) != SQLITE_ROW))
{ {
pk_backend_job_error_code(job, pk_backend_job_error_code(job,
@@ -971,14 +924,14 @@ pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, gpointer us
sqlite3_errstr(ret)); sqlite3_errstr(ret));
goto out; goto out;
} }
if ((guint32) sqlite3_column_int(stmt, 0) > g_file_info_get_attribute_uint32(file_info, "time::modified-usec")) if ((std::uint32_t) sqlite3_column_int(stmt, 0) > g_file_info_get_attribute_uint32(file_info, "time::modified-usec"))
{ {
force = TRUE; force = true;
} }
} }
if (force) /* It should empty all tables */ if (force) /* It should empty all tables */
{ {
if (sqlite3_exec(job_data->db, "DELETE FROM repos", NULL, 0, &db_err) != SQLITE_OK) if (sqlite3_exec(job_data->db, "DELETE FROM repos", nullptr, 0, &db_err) != SQLITE_OK)
{ {
pk_backend_job_error_code(job, PK_ERROR_ENUM_INTERNAL_ERROR, "%s", db_err); pk_backend_job_error_code(job, PK_ERROR_ENUM_INTERNAL_ERROR, "%s", db_err);
sqlite3_free(db_err); sqlite3_free(db_err);
@@ -998,8 +951,8 @@ pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, gpointer us
for (GSList *l = file_list; l; l = g_slist_next(l)) for (GSList *l = file_list; l; l = g_slist_next(l))
{ {
get_file(&job_data->curl, static_cast<gchar **> (l->data)[0], get_file(&job_data->curl, static_cast<char **> (l->data)[0],
static_cast<gchar **> (l->data)[1]); static_cast<char **> (l->data)[1]);
} }
g_slist_free_full(file_list, (GDestroyNotify)g_strfreev); g_slist_free_full(file_list, (GDestroyNotify)g_strfreev);
@@ -1029,43 +982,43 @@ out:
} }
void void
pk_backend_refresh_cache(PkBackend *backend, PkBackendJob *job, gboolean force) pk_backend_refresh_cache(PkBackend *backend, PkBackendJob *job, bool force)
{ {
pk_backend_job_thread_create(job, pk_backend_refresh_cache_thread, NULL, NULL); pk_backend_job_thread_create(job, pk_backend_refresh_cache_thread, nullptr, nullptr);
} }
static void static void
pk_backend_get_update_detail_thread(PkBackendJob *job, GVariant *params, gpointer user_data) pk_backend_get_update_detail_thread(PkBackendJob *job, GVariant *params, void *user_data)
{ {
guint i; unsigned i;
gchar **pkg_ids; char **pkg_ids;
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY); pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
g_variant_get(params, "(^a&s)", &pkg_ids); g_variant_get(params, "(^a&s)", &pkg_ids);
for (i = 0; pkg_ids[i] != NULL; i++) for (i = 0; pkg_ids[i] != nullptr; i++)
{ {
pk_backend_job_update_detail (job, pk_backend_job_update_detail (job,
pkg_ids[i], pkg_ids[i],
NULL, nullptr,
NULL, nullptr,
NULL, nullptr,
NULL, nullptr,
NULL, nullptr,
PK_RESTART_ENUM_NONE, PK_RESTART_ENUM_NONE,
NULL, nullptr,
NULL, nullptr,
PK_UPDATE_STATE_ENUM_STABLE, PK_UPDATE_STATE_ENUM_STABLE,
NULL, nullptr,
NULL); nullptr);
} }
} }
void void
pk_backend_get_update_detail(PkBackend *backend, PkBackendJob *job, gchar **package_ids) pk_backend_get_update_detail(PkBackend *backend, PkBackendJob *job, char **package_ids)
{ {
pk_backend_job_thread_create(job, pk_backend_get_update_detail_thread, NULL, NULL); pk_backend_job_thread_create(job, pk_backend_get_update_detail_thread, nullptr, nullptr);
} }
PkBitfield PkBitfield

60
backend/pkgtools.cc
View File

@@ -1,7 +1,11 @@
/*
* 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 <curl/curl.h> #include <curl/curl.h>
#include <sqlite3.h> #include <sqlite3.h>
#include "pkgtools.h" #include "pkgtools.h"
#include "utils.h"
namespace slack { namespace slack {
@@ -15,46 +19,45 @@ namespace slack {
* *
* Returns: %TRUE on success, %FALSE otherwise. * Returns: %TRUE on success, %FALSE otherwise.
**/ **/
gboolean bool
Pkgtools::download (PkBackendJob *job, Pkgtools::download (JobData *job_data,
gchar *dest_dir_name, gchar *pkg_name) noexcept char *dest_dir_name, char *pkg_name) noexcept
{ {
gchar *dest_filename, *source_url; char *dest_filename, *source_url;
gboolean ret = FALSE; bool ret = false;
sqlite3_stmt *statement = NULL; sqlite3_stmt *statement = nullptr;
CURL *curl = NULL; CURL *curl = nullptr;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
if ((sqlite3_prepare_v2(job_data->db, if ((sqlite3_prepare_v2(job_data->db,
"SELECT location, (full_name || '.' || ext) FROM pkglist " "SELECT location, (full_name || '.' || ext) FROM pkglist "
"WHERE name LIKE @name AND repo_order = @repo_order", "WHERE name LIKE @name AND repo_order = @repo_order",
-1, -1,
&statement, &statement,
NULL) != SQLITE_OK)) nullptr) != SQLITE_OK))
return FALSE; return false;
sqlite3_bind_text(statement, 1, pkg_name, -1, SQLITE_TRANSIENT); sqlite3_bind_text(statement, 1, pkg_name, -1, SQLITE_TRANSIENT);
sqlite3_bind_int(statement, 2, this->get_order ()); sqlite3_bind_int(statement, 2, this->get_order ());
if (sqlite3_step(statement) == SQLITE_ROW) if (sqlite3_step(statement) == SQLITE_ROW)
{ {
dest_filename = g_build_filename(dest_dir_name, sqlite3_column_text(statement, 1), NULL); dest_filename = g_build_filename(dest_dir_name, sqlite3_column_text(statement, 1), nullptr);
source_url = g_strconcat(this->get_mirror (), source_url = g_strconcat(this->get_mirror (),
sqlite3_column_text(statement, 0), sqlite3_column_text(statement, 0),
"/", "/",
sqlite3_column_text(statement, 1), sqlite3_column_text(statement, 1),
NULL); nullptr);
if (!g_file_test(dest_filename, G_FILE_TEST_EXISTS)) if (!g_file_test(dest_filename, G_FILE_TEST_EXISTS))
{ {
if (get_file(&curl, source_url, dest_filename) == CURLE_OK) if (get_file(&curl, source_url, dest_filename) == CURLE_OK)
{ {
ret = TRUE; ret = true;
} }
} }
else else
{ {
ret = TRUE; ret = true;
} }
if (curl) if (curl)
@@ -71,24 +74,23 @@ Pkgtools::download (PkBackendJob *job,
/** /**
* slack::Pkgtools::install: * slack::Pkgtools::install:
* @job: A #PkBackendJob. * @job_data: A #JobData.
* @pkg_name: Package name. * @pkg_name: Package name.
* *
* Install a package. * Install a package.
**/ **/
void void
Pkgtools::install (PkBackendJob *job, gchar *pkg_name) noexcept Pkgtools::install (JobData *job_data, char *pkg_name) noexcept
{ {
gchar *pkg_filename, *cmd_line; char *pkg_filename, *cmd_line;
sqlite3_stmt *statement = NULL; sqlite3_stmt *statement = nullptr;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
if ((sqlite3_prepare_v2(job_data->db, if ((sqlite3_prepare_v2(job_data->db,
"SELECT (full_name || '.' || ext) FROM pkglist " "SELECT (full_name || '.' || ext) FROM pkglist "
"WHERE name LIKE @name AND repo_order = @repo_order", "WHERE name LIKE @name AND repo_order = @repo_order",
-1, -1,
&statement, &statement,
NULL) != SQLITE_OK)) nullptr) != SQLITE_OK))
{ {
return; return;
} }
@@ -103,9 +105,9 @@ Pkgtools::install (PkBackendJob *job, gchar *pkg_name) noexcept
"PackageKit", "PackageKit",
"downloads", "downloads",
sqlite3_column_text(statement, 0), sqlite3_column_text(statement, 0),
NULL); nullptr);
cmd_line = g_strconcat("/sbin/upgradepkg --install-new ", pkg_filename, NULL); cmd_line = g_strconcat("/sbin/upgradepkg --install-new ", pkg_filename, nullptr);
g_spawn_command_line_sync(cmd_line, NULL, NULL, NULL, NULL); g_spawn_command_line_sync(cmd_line, nullptr, nullptr, nullptr, nullptr);
g_free(cmd_line); g_free(cmd_line);
g_free(pkg_filename); g_free(pkg_filename);
@@ -124,7 +126,7 @@ Pkgtools::~Pkgtools () noexcept
* *
* Returns: Repository name. * Returns: Repository name.
**/ **/
const gchar * const char *
Pkgtools::get_name () const noexcept Pkgtools::get_name () const noexcept
{ {
return this->name; return this->name;
@@ -137,7 +139,7 @@ Pkgtools::get_name () const noexcept
* *
* Returns: Repository mirror. * Returns: Repository mirror.
**/ **/
const gchar * const char *
Pkgtools::get_mirror () const noexcept Pkgtools::get_mirror () const noexcept
{ {
return this->mirror; return this->mirror;
@@ -164,12 +166,12 @@ Pkgtools::get_order () const noexcept
* *
* Returns: %TRUE if the package is blacklisted, %FALSE otherwise. * Returns: %TRUE if the package is blacklisted, %FALSE otherwise.
**/ **/
gboolean bool
Pkgtools::is_blacklisted (const gchar *pkg) const noexcept Pkgtools::is_blacklisted (const char *pkg) const noexcept
{ {
return this->blacklist return this->blacklist
&& g_regex_match (this->blacklist, && g_regex_match (this->blacklist,
pkg, static_cast<GRegexMatchFlags> (0), NULL); pkg, static_cast<GRegexMatchFlags> (0), nullptr);
} }
} }

40
backend/pkgtools.h
View File

@@ -1,36 +1,40 @@
#ifndef __SLACK_PKGTOOLS_H /*
#define __SLACK_PKGTOOLS_H * 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 <cstdint>
#include <glib-object.h> #include <glib-object.h>
#include <pk-backend.h> #include <pk-backend.h>
#include "utils.h"
namespace slack { namespace slack {
class Pkgtools class Pkgtools
{ {
public: public:
const gchar *get_name () const noexcept; const char *get_name () const noexcept;
const gchar *get_mirror () const noexcept; const char *get_mirror () const noexcept;
guint8 get_order () const noexcept; std::uint8_t get_order () const noexcept;
gboolean is_blacklisted (const gchar *pkg) const noexcept; bool is_blacklisted (const char *pkg) const noexcept;
virtual ~Pkgtools () noexcept; virtual ~Pkgtools () noexcept;
gboolean download (PkBackendJob *job, bool download (JobData *job_data,
gchar *dest_dir_name, gchar *pkg_name) noexcept; char *dest_dir_name, char *pkg_name) noexcept;
void install (PkBackendJob *job, gchar *pkg_name) noexcept; void install (JobData *job_data, char *pkg_name) noexcept;
virtual GSList *collect_cache_info (const gchar *tmpl) noexcept = 0; virtual GSList *collect_cache_info (const char *tmpl) noexcept = 0;
virtual void generate_cache (PkBackendJob *job, virtual void generate_cache (JobData *job_data,
const gchar *tmpl) noexcept = 0; const char *tmpl) noexcept = 0;
protected: protected:
gchar *name = NULL; char *name = nullptr;
gchar *mirror = NULL; char *mirror = nullptr;
guint8 order; std::uint8_t order;
GRegex *blacklist = NULL; GRegex *blacklist = nullptr;
}; };
} }
#endif /* __SLACK_PKGTOOLS_H */

167
backend/slackpkg.cc
View File

@@ -7,7 +7,7 @@
namespace slack { namespace slack {
GHashTable *Slackpkg::cat_map = NULL; GHashTable *Slackpkg::cat_map = nullptr;
/* /*
* slack::Slackpkg::manifest: * slack::Slackpkg::manifest:
@@ -19,24 +19,24 @@ GHashTable *Slackpkg::cat_map = NULL;
*/ */
void void
Slackpkg::manifest (PkBackendJob *job, Slackpkg::manifest (PkBackendJob *job,
const gchar *tmpl, gchar *filename) noexcept const char *tmpl, char *filename) noexcept
{ {
FILE *manifest; FILE *manifest;
gint err, read_len; int err, read_len;
guint pos; unsigned pos;
gchar buf[max_buf_size], *path, *pkg_filename, *rest = NULL, *start; char buf[max_buf_size], *path, *pkg_filename, *rest = nullptr, *start;
gchar *full_name = NULL; char *full_name = nullptr;
gchar **line, **lines; char **line, **lines;
BZFILE *manifest_bz2; BZFILE *manifest_bz2;
GRegex *pkg_expr = NULL, *file_expr = NULL; GRegex *pkg_expr = nullptr, *file_expr = nullptr;
GMatchInfo *match_info; GMatchInfo *match_info;
sqlite3_stmt *statement = NULL; sqlite3_stmt *statement = nullptr;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job)); auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
path = g_build_filename(tmpl, path = g_build_filename(tmpl,
this->get_name (), this->get_name (),
filename, filename,
NULL); nullptr);
manifest = fopen(path, "rb"); manifest = fopen(path, "rb");
g_free(path); g_free(path);
@@ -44,7 +44,7 @@ Slackpkg::manifest (PkBackendJob *job,
{ {
return; return;
} }
if (!(manifest_bz2 = BZ2_bzReadOpen(&err, manifest, 0, 0, NULL, 0))) if (!(manifest_bz2 = BZ2_bzReadOpen(&err, manifest, 0, 0, nullptr, 0)))
{ {
goto out; goto out;
} }
@@ -53,14 +53,14 @@ Slackpkg::manifest (PkBackendJob *job,
pkg_expr = g_regex_new("^\\|\\|[[:blank:]]+Package:[[:blank:]]+.+\\/(.+)\\.(t[blxg]z$)?", pkg_expr = g_regex_new("^\\|\\|[[:blank:]]+Package:[[:blank:]]+.+\\/(.+)\\.(t[blxg]z$)?",
static_cast<GRegexCompileFlags> (G_REGEX_OPTIMIZE | G_REGEX_DUPNAMES), static_cast<GRegexCompileFlags> (G_REGEX_OPTIMIZE | G_REGEX_DUPNAMES),
static_cast<GRegexMatchFlags> (0), static_cast<GRegexMatchFlags> (0),
NULL); nullptr);
file_expr = g_regex_new("^[-bcdlps][-r][-w][-xsS][-r][-w][-xsS][-r][-w]" file_expr = g_regex_new("^[-bcdlps][-r][-w][-xsS][-r][-w][-xsS][-r][-w]"
"[-xtT][[:space:]][^[:space:]]+[[:space:]]+" "[-xtT][[:space:]][^[:space:]]+[[:space:]]+"
"[[:digit:]]+[[:space:]][[:digit:]-]+[[:space:]]" "[[:digit:]]+[[:space:]][[:digit:]-]+[[:space:]]"
"[[:digit:]:]+[[:space:]](?!install\\/|\\.)(.*)", "[[:digit:]:]+[[:space:]](?!install\\/|\\.)(.*)",
static_cast<GRegexCompileFlags> (G_REGEX_OPTIMIZE | G_REGEX_DUPNAMES), static_cast<GRegexCompileFlags> (G_REGEX_OPTIMIZE | G_REGEX_DUPNAMES),
static_cast<GRegexMatchFlags> (0), static_cast<GRegexMatchFlags> (0),
NULL); nullptr);
if (!(file_expr) || !(pkg_expr)) if (!(file_expr) || !(pkg_expr))
{ {
goto out; goto out;
@@ -71,12 +71,12 @@ Slackpkg::manifest (PkBackendJob *job,
"INSERT INTO filelist (full_name, filename) VALUES (@full_name, @filename)", "INSERT INTO filelist (full_name, filename) VALUES (@full_name, @filename)",
-1, -1,
&statement, &statement,
NULL) != SQLITE_OK) nullptr) != SQLITE_OK)
{ {
goto out; goto out;
} }
sqlite3_exec(job_data->db, "BEGIN TRANSACTION", NULL, NULL, NULL); sqlite3_exec(job_data->db, "BEGIN TRANSACTION", nullptr, nullptr, nullptr);
while ((read_len = BZ2_bzRead(&err, manifest_bz2, buf, max_buf_size - 1))) while ((read_len = BZ2_bzRead(&err, manifest_bz2, buf, max_buf_size - 1)))
{ {
if ((err != BZ_OK) && (err != BZ_STREAM_END)) if ((err != BZ_OK) && (err != BZ_STREAM_END))
@@ -90,7 +90,7 @@ Slackpkg::manifest (PkBackendJob *job,
if (rest) if (rest)
{ /* Add to the first line rest characters from the previous read operation */ { /* Add to the first line rest characters from the previous read operation */
start = lines[0]; start = lines[0];
lines[0] = g_strconcat(rest, lines[0], NULL); lines[0] = g_strconcat(rest, lines[0], nullptr);
g_free(start); g_free(start);
g_free(rest); g_free(rest);
} }
@@ -98,7 +98,7 @@ Slackpkg::manifest (PkBackendJob *job,
{ {
pos = g_strv_length(lines) - 1; pos = g_strv_length(lines) - 1;
rest = lines[pos]; rest = lines[pos];
lines[pos] = NULL; lines[pos] = nullptr;
} }
for (line = lines; *line; line++) for (line = lines; *line; line++)
{ {
@@ -111,12 +111,12 @@ Slackpkg::manifest (PkBackendJob *job,
} }
else else
{ {
full_name = NULL; full_name = nullptr;
} }
} }
g_match_info_free(match_info); g_match_info_free(match_info);
match_info = NULL; match_info = nullptr;
if (full_name && g_regex_match(file_expr, *line, static_cast<GRegexMatchFlags> (0), &match_info)) if (full_name && g_regex_match(file_expr, *line, static_cast<GRegexMatchFlags> (0), &match_info))
{ {
pkg_filename = g_match_info_fetch(match_info, 1); pkg_filename = g_match_info_fetch(match_info, 1);
@@ -132,7 +132,7 @@ Slackpkg::manifest (PkBackendJob *job,
g_strfreev(lines); g_strfreev(lines);
} }
sqlite3_exec(job_data->db, "END TRANSACTION", NULL, NULL, NULL); sqlite3_exec(job_data->db, "END TRANSACTION", nullptr, nullptr, nullptr);
g_free(full_name); g_free(full_name);
BZ2_bzReadClose(&err, manifest_bz2); BZ2_bzReadClose(&err, manifest_bz2);
@@ -159,33 +159,33 @@ out:
* Returns: List of files needed for building the cache. * Returns: List of files needed for building the cache.
**/ **/
GSList * GSList *
Slackpkg::collect_cache_info (const gchar *tmpl) noexcept Slackpkg::collect_cache_info (const char *tmpl) noexcept
{ {
CURL *curl = NULL; CURL *curl = nullptr;
gchar **source_dest; char **source_dest;
GSList *file_list = NULL; GSList *file_list = nullptr;
GFile *tmp_dir, *repo_tmp_dir; GFile *tmp_dir, *repo_tmp_dir;
/* Create the temporary directory for the repository */ /* Create the temporary directory for the repository */
tmp_dir = g_file_new_for_path(tmpl); 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, NULL, NULL); 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 */ /* Download PACKAGES.TXT. These files are most important, break if some of them couldn't be found */
for (gchar **cur_priority = this->priority; *cur_priority; cur_priority++) for (char **cur_priority = this->priority; *cur_priority; cur_priority++)
{ {
source_dest = static_cast<gchar **> (g_malloc_n(3, sizeof(gchar *))); source_dest = static_cast<char **> (g_malloc_n(3, sizeof(char *)));
source_dest[0] = g_strconcat(this->get_mirror (), source_dest[0] = g_strconcat(this->get_mirror (),
*cur_priority, *cur_priority,
"/PACKAGES.TXT", "/PACKAGES.TXT",
NULL); nullptr);
source_dest[1] = g_build_filename(tmpl, source_dest[1] = g_build_filename(tmpl,
this->get_name (), this->get_name (),
"PACKAGES.TXT", "PACKAGES.TXT",
NULL); nullptr);
source_dest[2] = NULL; source_dest[2] = nullptr;
if (get_file(&curl, source_dest[0], NULL) == CURLE_OK) if (get_file(&curl, source_dest[0], nullptr) == CURLE_OK)
{ {
file_list = g_slist_prepend(file_list, source_dest); file_list = g_slist_prepend(file_list, source_dest);
} }
@@ -197,17 +197,17 @@ Slackpkg::collect_cache_info (const gchar *tmpl) noexcept
} }
/* Download file lists if available */ /* Download file lists if available */
source_dest = static_cast<gchar **> (g_malloc_n(3, sizeof(gchar *))); source_dest = static_cast<char **> (g_malloc_n(3, sizeof(char *)));
source_dest[0] = g_strconcat(this->get_mirror (), source_dest[0] = g_strconcat(this->get_mirror (),
*cur_priority, *cur_priority,
"/MANIFEST.bz2", "/MANIFEST.bz2",
NULL); nullptr);
source_dest[1] = g_strconcat(tmpl, source_dest[1] = g_strconcat(tmpl,
"/", this->get_name (), "/", this->get_name (),
"/", *cur_priority, "-MANIFEST.bz2", "/", *cur_priority, "-MANIFEST.bz2",
NULL); nullptr);
source_dest[2] = NULL; source_dest[2] = nullptr;
if (get_file(&curl, source_dest[0], NULL) == CURLE_OK) if (get_file(&curl, source_dest[0], nullptr) == CURLE_OK)
{ {
file_list = g_slist_prepend(file_list, source_dest); file_list = g_slist_prepend(file_list, source_dest);
} }
@@ -229,7 +229,7 @@ out:
/** /**
* slack::Slackpkg::generate_cache: * slack::Slackpkg::generate_cache:
* @job: A #PkBackendJob. * @job_data: A #JobData.
* @tmpl: temporary directory for downloading the files. * @tmpl: temporary directory for downloading the files.
* *
* Download files needed to get the information like the list of packages * Download files needed to get the information like the list of packages
@@ -238,26 +238,25 @@ out:
* Returns: List of files needed for building the cache. * Returns: List of files needed for building the cache.
**/ **/
void void
Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept Slackpkg::generate_cache (JobData *job_data, const char *tmpl) noexcept
{ {
gchar **pkg_tokens = NULL; char **pkg_tokens = nullptr;
gchar *query = NULL, *filename = NULL, *location = NULL, *summary = NULL, *line, *packages_txt; char *query = nullptr, *filename = nullptr, *location = nullptr, *summary = nullptr, *line, *packages_txt;
guint pkg_compressed = 0, pkg_uncompressed = 0; unsigned pkg_compressed = 0, pkg_uncompressed = 0;
gushort pkg_name_len; gushort pkg_name_len;
GString *desc; GString *desc;
GFile *list_file; GFile *list_file;
GFileInputStream *fin = NULL; GFileInputStream *fin = nullptr;
GDataInputStream *data_in = NULL; GDataInputStream *data_in = nullptr;
sqlite3_stmt *insert_statement = NULL, *update_statement = NULL, *insert_default_statement = NULL, *statement; sqlite3_stmt *insert_statement = nullptr, *update_statement = nullptr, *insert_default_statement = nullptr, *statement;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
/* Check if the temporary directory for this repository exists, then the file metadata have to be generated */ /* Check if the temporary directory for this repository exists, then the file metadata have to be generated */
packages_txt = g_build_filename(tmpl, packages_txt = g_build_filename(tmpl,
this->get_name (), this->get_name (),
"PACKAGES.TXT", "PACKAGES.TXT",
NULL); nullptr);
list_file = g_file_new_for_path(packages_txt); list_file = g_file_new_for_path(packages_txt);
fin = g_file_read(list_file, NULL, NULL); fin = g_file_read(list_file, nullptr, nullptr);
g_object_unref(list_file); g_object_unref(list_file);
g_free(packages_txt); g_free(packages_txt);
if (!fin) if (!fin)
@@ -269,7 +268,7 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
"DELETE FROM repos WHERE repo LIKE @repo", "DELETE FROM repos WHERE repo LIKE @repo",
-1, -1,
&statement, &statement,
NULL) == SQLITE_OK) nullptr) == SQLITE_OK)
{ {
sqlite3_bind_text(statement, sqlite3_bind_text(statement,
1, 1,
@@ -283,7 +282,7 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
"INSERT INTO repos (repo_order, repo) VALUES (@repo_order, @repo)", "INSERT INTO repos (repo_order, repo) VALUES (@repo_order, @repo)",
-1, -1,
&statement, &statement,
NULL) != SQLITE_OK) nullptr) != SQLITE_OK)
{ {
goto out; goto out;
} }
@@ -304,7 +303,7 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
"@desc, @compressed, @uncompressed, @name, @repo_order, @cat)", "@desc, @compressed, @uncompressed, @name, @repo_order, @cat)",
-1, -1,
&insert_statement, &insert_statement,
NULL) != SQLITE_OK) nullptr) != SQLITE_OK)
|| (sqlite3_prepare_v2(job_data->db, || (sqlite3_prepare_v2(job_data->db,
"INSERT OR REPLACE INTO pkglist (full_name, ver, arch, ext, location, " "INSERT OR REPLACE INTO pkglist (full_name, ver, arch, ext, location, "
"summary, desc, compressed, uncompressed, name, repo_order) " "summary, desc, compressed, uncompressed, name, repo_order) "
@@ -312,7 +311,7 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
"@desc, @compressed, @uncompressed, @name, @repo_order)", "@desc, @compressed, @uncompressed, @name, @repo_order)",
-1, -1,
&insert_default_statement, &insert_default_statement,
NULL) != SQLITE_OK)) nullptr) != SQLITE_OK))
{ {
goto out; goto out;
} }
@@ -321,7 +320,7 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
"desc = @desc, compressed = @compressed, uncompressed = @uncompressed " "desc = @desc, compressed = @compressed, uncompressed = @uncompressed "
"WHERE name LIKE @name AND repo_order = %u", "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, NULL) != SQLITE_OK) if (sqlite3_prepare_v2(job_data->db, query, -1, &update_statement, nullptr) != SQLITE_OK)
{ {
goto out; goto out;
} }
@@ -329,9 +328,9 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
data_in = g_data_input_stream_new(G_INPUT_STREAM(fin)); data_in = g_data_input_stream_new(G_INPUT_STREAM(fin));
desc = g_string_new(""); desc = g_string_new("");
sqlite3_exec(job_data->db, "BEGIN TRANSACTION", NULL, NULL, NULL); sqlite3_exec(job_data->db, "BEGIN TRANSACTION", nullptr, nullptr, nullptr);
while ((line = g_data_input_stream_read_line(data_in, NULL, NULL, NULL))) while ((line = g_data_input_stream_read_line(data_in, nullptr, nullptr, nullptr)))
{ {
if (!strncmp(line, "PACKAGE NAME: ", 15)) if (!strncmp(line, "PACKAGE NAME: ", 15))
{ {
@@ -339,7 +338,7 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
if (this->is_blacklisted (filename)) if (this->is_blacklisted (filename))
{ {
g_free(filename); g_free(filename);
filename = NULL; filename = nullptr;
} }
} }
else if (filename && !strncmp(line, "PACKAGE LOCATION: ", 19)) else if (filename && !strncmp(line, "PACKAGE LOCATION: ", 19))
@@ -359,10 +358,10 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
else if (filename && !g_strcmp0(line, "PACKAGE DESCRIPTION:")) else if (filename && !g_strcmp0(line, "PACKAGE DESCRIPTION:"))
{ {
g_free(line); g_free(line);
line = g_data_input_stream_read_line(data_in, NULL, NULL, NULL); /* Short description */ line = g_data_input_stream_read_line(data_in, nullptr, nullptr, nullptr); /* Short description */
summary = g_strstr_len(line, -1, "("); summary = g_strstr_len(line, -1, "(");
if (summary) /* Else summary = NULL */ if (summary) /* Else summary = nullptr */
{ {
summary = g_strndup(summary + 1, strlen(summary) - 2); /* Without ( ) */ summary = g_strndup(summary + 1, strlen(summary) - 2); /* Without ( ) */
} }
@@ -379,7 +378,7 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
{ {
/* Get the package group based on its location */ /* Get the package group based on its location */
const char *cat = g_strrstr(location, "/"); const char *cat = g_strrstr(location, "/");
if (cat) /* Else cat = NULL */ if (cat) /* Else cat = nullptr */
{ {
cat = static_cast<const char *> (g_hash_table_lookup(cat_map, cat + 1)); cat = static_cast<const char *> (g_hash_table_lookup(cat_map, cat + 1));
} }
@@ -418,21 +417,21 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
g_free(filename); g_free(filename);
g_free(location); g_free(location);
g_free(summary); g_free(summary);
filename = location = summary = NULL; filename = location = summary = nullptr;
g_string_assign(desc, ""); g_string_assign(desc, "");
pkg_compressed = pkg_uncompressed = 0; pkg_compressed = pkg_uncompressed = 0;
} }
g_free(line); g_free(line);
} }
sqlite3_exec(job_data->db, "END TRANSACTION", NULL, NULL, NULL); sqlite3_exec(job_data->db, "END TRANSACTION", nullptr, nullptr, nullptr);
g_string_free(desc, TRUE); g_string_free(desc, true);
g_object_unref(data_in); g_object_unref(data_in);
/* Parse MANIFEST.bz2 */ /* Parse MANIFEST.bz2 */
for (gchar **p = this->priority; *p; p++) for (char **p = this->priority; *p; p++)
{ {
filename = g_strconcat(*p, "-MANIFEST.bz2", NULL); filename = g_strconcat(*p, "-MANIFEST.bz2", nullptr);
manifest (job, tmpl, filename); manifest (job, tmpl, filename);
g_free(filename); g_free(filename);
} }
@@ -475,19 +474,19 @@ Slackpkg::~Slackpkg () noexcept
* *
* Returns: New #slack::Slackpkg. * Returns: New #slack::Slackpkg.
**/ **/
Slackpkg::Slackpkg (const gchar *name, const gchar *mirror, Slackpkg::Slackpkg (const char *name, const char *mirror,
guint8 order, const gchar *blacklist, gchar **priority) noexcept std::uint8_t order, const char *blacklist, char **priority) noexcept
{ {
GRegex *regex; GRegex *regex;
if (blacklist) if (blacklist)
{ {
regex = static_cast<GRegex *> (g_regex_new (blacklist, regex = static_cast<GRegex *> (g_regex_new (blacklist,
G_REGEX_OPTIMIZE, static_cast<GRegexMatchFlags> (0), NULL)); G_REGEX_OPTIMIZE, static_cast<GRegexMatchFlags> (0), nullptr));
} }
else else
{ {
regex = NULL; regex = nullptr;
} }
this->name = g_strdup (name); this->name = g_strdup (name);
@@ -500,25 +499,25 @@ Slackpkg::Slackpkg (const gchar *name, const gchar *mirror,
this->priority = priority; this->priority = priority;
// Initialize category map // Initialize category map
if (cat_map == NULL) if (cat_map == nullptr)
{ {
cat_map = g_hash_table_new(g_str_hash, g_str_equal); cat_map = g_hash_table_new(g_str_hash, g_str_equal);
g_hash_table_insert (cat_map, (gpointer) "a", (gpointer) "system"); g_hash_table_insert (cat_map, (void *) "a", (void *) "system");
g_hash_table_insert (cat_map, (gpointer) "ap", (gpointer) "admin-tools"); g_hash_table_insert (cat_map, (void *) "ap", (void *) "admin-tools");
g_hash_table_insert (cat_map, (gpointer) "d", (gpointer) "programming"); g_hash_table_insert (cat_map, (void *) "d", (void *) "programming");
g_hash_table_insert (cat_map, (gpointer) "e", (gpointer) "programming"); g_hash_table_insert (cat_map, (void *) "e", (void *) "programming");
g_hash_table_insert (cat_map, (gpointer) "f", (gpointer) "documentation"); g_hash_table_insert (cat_map, (void *) "f", (void *) "documentation");
g_hash_table_insert (cat_map, (gpointer) "k", (gpointer) "system"); g_hash_table_insert (cat_map, (void *) "k", (void *) "system");
g_hash_table_insert (cat_map, (gpointer) "kde", (gpointer) "desktop-kde"); g_hash_table_insert (cat_map, (void *) "kde", (void *) "desktop-kde");
g_hash_table_insert (cat_map, (gpointer) "kdei", (gpointer) "localization"); g_hash_table_insert (cat_map, (void *) "kdei", (void *) "localization");
g_hash_table_insert (cat_map, (gpointer) "l", (gpointer) "system"); g_hash_table_insert (cat_map, (void *) "l", (void *) "system");
g_hash_table_insert (cat_map, (gpointer) "n", (gpointer) "network"); g_hash_table_insert (cat_map, (void *) "n", (void *) "network");
g_hash_table_insert (cat_map, (gpointer) "t", (gpointer) "publishing"); g_hash_table_insert (cat_map, (void *) "t", (void *) "publishing");
g_hash_table_insert (cat_map, (gpointer) "tcl", (gpointer) "system"); g_hash_table_insert (cat_map, (void *) "tcl", (void *) "system");
g_hash_table_insert (cat_map, (gpointer) "x", (gpointer) "desktop-other"); g_hash_table_insert (cat_map, (void *) "x", (void *) "desktop-other");
g_hash_table_insert (cat_map, (gpointer) "xap", (gpointer) "accessories"); g_hash_table_insert (cat_map, (void *) "xap", (void *) "accessories");
g_hash_table_insert (cat_map, (gpointer) "xfce", (gpointer) "desktop-xfce"); g_hash_table_insert (cat_map, (void *) "xfce", (void *) "desktop-xfce");
g_hash_table_insert (cat_map, (gpointer) "y", (gpointer) "games"); g_hash_table_insert (cat_map, (void *) "y", (void *) "games");
} }
} }

24
backend/slackpkg.h
View File

@@ -1,30 +1,34 @@
#ifndef __SLACK_SLACKPKG_H /*
#define __SLACK_SLACKPKG_H * 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 <cstdint>
#include <cstddef> #include <cstddef>
#include "pkgtools.h" #include "pkgtools.h"
#include "utils.h"
namespace slack { namespace slack {
class Slackpkg final : public Pkgtools class Slackpkg final : public Pkgtools
{ {
public: public:
Slackpkg (const gchar *name, const gchar *mirror, Slackpkg (const char *name, const char *mirror,
guint8 order, const gchar *blacklist, gchar **priority) noexcept; std::uint8_t order, const char *blacklist, char **priority) noexcept;
~Slackpkg () noexcept; ~Slackpkg () noexcept;
GSList *collect_cache_info (const gchar *tmpl) noexcept; GSList *collect_cache_info (const char *tmpl) noexcept;
void generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept; void generate_cache (JobData *job_data, const char *tmpl) noexcept;
private: private:
static GHashTable *cat_map; static GHashTable *cat_map;
static const std::size_t max_buf_size = 8192; static const std::size_t max_buf_size = 8192;
gchar **priority = NULL; char **priority = nullptr;
void manifest (PkBackendJob *job, void manifest (PkBackendJob *job,
const gchar *tmpl, gchar *filename) noexcept; const char *tmpl, char *filename) noexcept;
}; };
} }
#endif /* __SLACK_SLACKPKG_H */

68
backend/tests/definitions.cc
View File

@@ -1,27 +1,33 @@
/*
* 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 <cstdint>
#include "pk-backend.h" #include "pk-backend.h"
#include <pk-backend-job.h> #include <pk-backend-job.h>
gpointer void *
pk_backend_job_get_user_data (PkBackendJob *job) pk_backend_job_get_user_data (PkBackendJob *job)
{ {
return NULL; return nullptr;
} }
void void
pk_backend_job_set_user_data (PkBackendJob *job, gpointer user_data) pk_backend_job_set_user_data (PkBackendJob *job, void *user_data)
{ {
} }
void void
pk_backend_job_set_allow_cancel (PkBackendJob *job, gboolean allow_cancel) pk_backend_job_set_allow_cancel (PkBackendJob *job, bool allow_cancel)
{ {
} }
void void
pk_backend_job_package (PkBackendJob *job, pk_backend_job_package (PkBackendJob *job,
PkInfoEnum info, PkInfoEnum info,
const gchar *package_id, const char *package_id,
const gchar *summary) const char *summary)
{ {
} }
@@ -31,62 +37,62 @@ pk_backend_job_set_status (PkBackendJob *job, PkStatusEnum status)
} }
void void
pk_backend_job_set_percentage (PkBackendJob *job, guint percentage) pk_backend_job_set_percentage (PkBackendJob *job, unsigned percentage)
{ {
} }
void void
pk_backend_job_error_code (PkBackendJob *job, pk_backend_job_error_code (PkBackendJob *job,
PkErrorEnum error_code, const gchar *format, ...) PkErrorEnum error_code, const char *format, ...)
{ {
} }
void void
pk_backend_job_files (PkBackendJob *job, pk_backend_job_files (PkBackendJob *job,
const gchar *package_id, gchar **files) const char *package_id, char **files)
{ {
} }
void void
pk_backend_job_details (PkBackendJob *job, pk_backend_job_details (PkBackendJob *job,
const gchar *package_id, const char *package_id,
const gchar *summary, const char *summary,
const gchar *license, const char *license,
PkGroupEnum group, PkGroupEnum group,
const gchar *description, const char *description,
const gchar *url, const char *url,
gulong size, unsigned long size,
guint64 download_size) std::uint64_t download_size)
{ {
} }
void void
pk_backend_job_update_detail (PkBackendJob *job, pk_backend_job_update_detail (PkBackendJob *job,
const gchar *package_id, const char *package_id,
gchar **updates, char **updates,
gchar **obsoletes, char **obsoletes,
gchar **vendor_urls, char **vendor_urls,
gchar **bugzilla_urls, char **bugzilla_urls,
gchar **cve_urls, char **cve_urls,
PkRestartEnum restart, PkRestartEnum restart,
const gchar *update_text, const char *update_text,
const gchar *changelog, const char *changelog,
PkUpdateStateEnum state, PkUpdateStateEnum state,
const gchar *issued, const char *issued,
const gchar *updated) const char *updated)
{ {
} }
gboolean bool
pk_backend_job_thread_create (PkBackendJob *job, pk_backend_job_thread_create (PkBackendJob *job,
PkBackendJobThreadFunc func, PkBackendJobThreadFunc func,
gpointer user_data, void *user_data,
GDestroyNotify destroy_func) GDestroyNotify destroy_func)
{ {
return FALSE; return false;
} }
gboolean pk_directory_remove_contents (const gchar *directory) bool pk_directory_remove_contents (const char *directory)
{ {
return TRUE; return true;
} }

9
backend/tests/dl-test.cc
View File

@@ -1,3 +1,8 @@
/*
* 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 "dl.h" #include "dl.h"
using namespace slack; using namespace slack;
@@ -5,7 +10,7 @@ using namespace slack;
static void static void
slack_test_dl_construct() slack_test_dl_construct()
{ {
auto dl = new Dl ("some", "mirror", 1, NULL, NULL); auto dl = new Dl ("some", "mirror", 1, nullptr, nullptr);
g_assert_cmpstr (dl->get_name (), ==, "some"); g_assert_cmpstr (dl->get_name (), ==, "some");
g_assert_cmpstr (dl->get_mirror (), ==, "mirror"); g_assert_cmpstr (dl->get_mirror (), ==, "mirror");
@@ -17,7 +22,7 @@ slack_test_dl_construct()
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
g_test_init(&argc, &argv, NULL); g_test_init(&argc, &argv, nullptr);
g_test_add_func("/slack/dl/construct", slack_test_dl_construct); g_test_add_func("/slack/dl/construct", slack_test_dl_construct);

9
backend/tests/slackpkg-test.cc
View File

@@ -1,3 +1,8 @@
/*
* 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 "slackpkg.h" #include "slackpkg.h"
using namespace slack; using namespace slack;
@@ -5,7 +10,7 @@ using namespace slack;
static void static void
slack_test_slackpkg_construct() slack_test_slackpkg_construct()
{ {
auto slackpkg = new Slackpkg ("some", "mirror", 1, NULL, NULL); auto slackpkg = new Slackpkg ("some", "mirror", 1, nullptr, nullptr);
g_assert_cmpstr(slackpkg->get_name (), ==, "some"); g_assert_cmpstr(slackpkg->get_name (), ==, "some");
g_assert_cmpstr(slackpkg->get_mirror (), ==, "mirror"); g_assert_cmpstr(slackpkg->get_mirror (), ==, "mirror");
@@ -17,7 +22,7 @@ slack_test_slackpkg_construct()
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
g_test_init(&argc, &argv, NULL); g_test_init(&argc, &argv, nullptr);
g_test_add_func("/slack/slackpkg/construct", slack_test_slackpkg_construct); g_test_add_func("/slack/slackpkg/construct", slack_test_slackpkg_construct);

68
backend/utils.cc
View File

@@ -1,3 +1,9 @@
/*
* 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 <cstdint>
#include <sqlite3.h> #include <sqlite3.h>
#include <string.h> #include <string.h>
#include "utils.h" #include "utils.h"
@@ -16,14 +22,14 @@ namespace slack {
* Returns: CURLE_OK (zero) on success, non-zero otherwise. * Returns: CURLE_OK (zero) on success, non-zero otherwise.
**/ **/
CURLcode CURLcode
get_file (CURL **curl, gchar *source_url, gchar *dest) get_file (CURL **curl, char *source_url, char *dest)
{ {
gchar *dest_dir_name; char *dest_dir_name;
FILE *fout = NULL; FILE *fout = nullptr;
CURLcode ret; CURLcode ret;
glong response_code; glong response_code;
if ((*curl == NULL) && (!(*curl = curl_easy_init()))) if ((*curl == nullptr) && (!(*curl = curl_easy_init())))
{ {
return CURLE_BAD_FUNCTION_ARGUMENT; return CURLE_BAD_FUNCTION_ARGUMENT;
} }
@@ -31,7 +37,7 @@ get_file (CURL **curl, gchar *source_url, gchar *dest)
curl_easy_setopt(*curl, CURLOPT_FOLLOWLOCATION, 1L); curl_easy_setopt(*curl, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt(*curl, CURLOPT_URL, source_url); curl_easy_setopt(*curl, CURLOPT_URL, source_url);
if (dest == NULL) if (dest == nullptr)
{ {
curl_easy_setopt(*curl, CURLOPT_NOBODY, 1L); curl_easy_setopt(*curl, CURLOPT_NOBODY, 1L);
curl_easy_setopt(*curl, CURLOPT_HEADER, 1L); curl_easy_setopt(*curl, CURLOPT_HEADER, 1L);
@@ -48,10 +54,10 @@ get_file (CURL **curl, gchar *source_url, gchar *dest)
if (g_file_test(dest, G_FILE_TEST_IS_DIR)) if (g_file_test(dest, G_FILE_TEST_IS_DIR))
{ {
dest_dir_name = dest; dest_dir_name = dest;
dest = g_strconcat(dest_dir_name, g_strrstr(source_url, "/"), NULL); dest = g_strconcat(dest_dir_name, g_strrstr(source_url, "/"), nullptr);
g_free(dest_dir_name); g_free(dest_dir_name);
} }
if ((fout = fopen(dest, "ab")) == NULL) if ((fout = fopen(dest, "ab")) == nullptr)
{ {
return CURLE_WRITE_ERROR; return CURLE_WRITE_ERROR;
} }
@@ -59,7 +65,7 @@ get_file (CURL **curl, gchar *source_url, gchar *dest)
ret = curl_easy_perform(*curl); ret = curl_easy_perform(*curl);
} }
curl_easy_reset(*curl); curl_easy_reset(*curl);
if (fout != NULL) if (fout != nullptr)
{ {
fclose(fout); fclose(fout);
} }
@@ -70,23 +76,23 @@ get_file (CURL **curl, gchar *source_url, gchar *dest)
* slack::split_package_name: * slack::split_package_name:
* Got the name of a package, without version-arch-release data. * Got the name of a package, without version-arch-release data.
**/ **/
gchar ** char **
split_package_name (const gchar *pkg_filename) split_package_name (const char *pkg_filename)
{ {
gchar *pkg_full_name; char *pkg_full_name;
gchar **pkg_tokens; char **pkg_tokens;
g_return_val_if_fail(pkg_filename != NULL, NULL); g_return_val_if_fail(pkg_filename != nullptr, nullptr);
gint len = strlen(pkg_filename); int len = strlen(pkg_filename);
if (len < 4) if (len < 4)
{ {
return NULL; return nullptr;
} }
if (pkg_filename[len - 4] == '.') if (pkg_filename[len - 4] == '.')
{ {
pkg_tokens = static_cast<gchar **> (g_malloc_n (6, sizeof (gchar *))); pkg_tokens = static_cast<char **> (g_malloc_n (6, sizeof (char *)));
/* Full name without extension */ /* Full name without extension */
len -= 4; len -= 4;
@@ -95,18 +101,18 @@ split_package_name (const gchar *pkg_filename)
/* The last 3 characters should be the file extension */ /* The last 3 characters should be the file extension */
pkg_tokens[4] = g_strdup (pkg_filename + len + 1); pkg_tokens[4] = g_strdup (pkg_filename + len + 1);
pkg_tokens[5] = NULL; pkg_tokens[5] = nullptr;
} }
else else
{ {
pkg_tokens = static_cast<gchar **> (g_malloc_n (4, sizeof (gchar *))); pkg_tokens = static_cast<char **> (g_malloc_n (4, sizeof (char *)));
pkg_full_name = g_strdup (pkg_filename); pkg_full_name = g_strdup (pkg_filename);
pkg_tokens[3] = NULL; pkg_tokens[3] = nullptr;
} }
/* Reverse all of the bytes in the package filename to get the name, version and the architecture */ /* Reverse all of the bytes in the package filename to get the name, version and the architecture */
g_strreverse (pkg_full_name); g_strreverse (pkg_full_name);
gchar **reversed_tokens = g_strsplit (pkg_full_name, "-", 4); char **reversed_tokens = g_strsplit (pkg_full_name, "-", 4);
pkg_tokens[0] = g_strreverse (reversed_tokens[3]); /* Name */ pkg_tokens[0] = g_strreverse (reversed_tokens[3]); /* Name */
pkg_tokens[1] = g_strreverse (reversed_tokens[2]); /* Version */ pkg_tokens[1] = g_strreverse (reversed_tokens[2]); /* Version */
pkg_tokens[2] = g_strreverse (reversed_tokens[1]); /* Architecture */ pkg_tokens[2] = g_strreverse (reversed_tokens[1]); /* Architecture */
@@ -130,17 +136,17 @@ split_package_name (const gchar *pkg_filename)
* installed, PK_INFO_ENUM_UNKNOWN if pkg_fullname is malformed. * installed, PK_INFO_ENUM_UNKNOWN if pkg_fullname is malformed.
**/ **/
PkInfoEnum PkInfoEnum
is_installed (const gchar *pkg_fullname) is_installed (const char *pkg_fullname)
{ {
GFileEnumerator *pkg_metadata_enumerator; GFileEnumerator *pkg_metadata_enumerator;
GFileInfo *pkg_metadata_file_info; GFileInfo *pkg_metadata_file_info;
GFile *pkg_metadata_dir; GFile *pkg_metadata_dir;
PkInfoEnum ret = PK_INFO_ENUM_INSTALLING; PkInfoEnum ret = PK_INFO_ENUM_INSTALLING;
const gchar *it; const char *it;
guint8 dashes = 0; std::uint8_t dashes = 0;
ptrdiff_t pkg_name; ptrdiff_t pkg_name;
g_return_val_if_fail(pkg_fullname != NULL, PK_INFO_ENUM_UNKNOWN); g_return_val_if_fail(pkg_fullname != nullptr, PK_INFO_ENUM_UNKNOWN);
// We want to find the package name without version for the package we're // We want to find the package name without version for the package we're
// looking for. // looking for.
@@ -169,16 +175,16 @@ is_installed (const gchar *pkg_fullname)
if (!(pkg_metadata_enumerator = g_file_enumerate_children(pkg_metadata_dir, if (!(pkg_metadata_enumerator = g_file_enumerate_children(pkg_metadata_dir,
"standard::name", "standard::name",
G_FILE_QUERY_INFO_NONE, G_FILE_QUERY_INFO_NONE,
NULL, nullptr,
NULL))) nullptr)))
{ {
g_object_unref(pkg_metadata_dir); g_object_unref(pkg_metadata_dir);
return PK_INFO_ENUM_UNKNOWN; return PK_INFO_ENUM_UNKNOWN;
} }
while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, NULL, NULL))) while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, nullptr, nullptr)))
{ {
const gchar *dir = g_file_info_get_name(pkg_metadata_file_info); const char *dir = g_file_info_get_name(pkg_metadata_file_info);
dashes = 0; dashes = 0;
if (strcmp(dir, pkg_fullname) == 0) if (strcmp(dir, pkg_fullname) == 0)
@@ -220,12 +226,12 @@ is_installed (const gchar *pkg_fullname)
/** /**
* slack::cmp_repo: * slack::cmp_repo:
**/ **/
gint int
cmp_repo (gconstpointer a, gconstpointer b) cmp_repo (const void *a, const void *b)
{ {
auto repo = static_cast<const Pkgtools *> (a); auto repo = static_cast<const Pkgtools *> (a);
return g_strcmp0 (repo->get_name (), (gchar *) b); return g_strcmp0 (repo->get_name (), (char *) b);
} }
} }

20
backend/utils.h
View File

@@ -1,5 +1,9 @@
#ifndef __SLACK_UTILS_H /*
#define __SLACK_UTILS_H * 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 <curl/curl.h> #include <curl/curl.h>
#include <pk-backend.h> #include <pk-backend.h>
@@ -9,24 +13,20 @@ namespace slack {
struct JobData struct JobData
{ {
GObjectClass parent_class;
sqlite3 *db; sqlite3 *db;
CURL *curl; CURL *curl;
}; };
CURLcode get_file (CURL **curl, gchar *source_url, gchar *dest); CURLcode get_file (CURL **curl, char *source_url, char *dest);
gchar **split_package_name (const gchar *pkg_filename); char **split_package_name (const char *pkg_filename);
PkInfoEnum is_installed (const gchar *pkg_fullname); PkInfoEnum is_installed (const char *pkg_fullname);
extern "C" { extern "C" {
gint cmp_repo (gconstpointer a, gconstpointer b); int cmp_repo (const void *a, const void *b);
} }
} }
#endif /* __SLACK_UTILS_H */

8
katja.toml.dist
View File

@@ -1,2 +1,10 @@
# It is a sample configuration.
[sbo] [sbo]
path = "/home/path/to/local/repository" path = "/home/path/to/local/repository"
[slackware]
Mirror=http://mirrors.slackware.com/slackware/slackware64-15.0/
Priority=patches;@pkgmain@;extra;pasture;testing
#Blacklist=