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)
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_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set(CMAKE_CXX_STANDARD 23)
find_package(Boost REQUIRED)
add_library(katja)
target_sources(katja PUBLIC FILE_SET all_my_modules TYPE CXX_MODULES FILES
katja/database.cpp katja/repository.cpp katja/sbo.cpp)
include_directories(include ${Boost_INCLUDE_DIR})
if(KATJA_BUILD_TUI)
# add_subdirectory(backend)
if(KATJA_BUILD_CLI)
add_subdirectory(cli)
endif()
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 <stdlib.h>
#include "dl.h"
@@ -15,27 +20,27 @@ namespace slack {
* Returns: List of files needed for building the cache.
**/
GSList *
Dl::collect_cache_info (const gchar *tmpl) noexcept
Dl::collect_cache_info (const char *tmpl) noexcept
{
CURL *curl = NULL;
GSList *file_list = NULL;
CURL *curl = nullptr;
GSList *file_list = nullptr;
GFile *tmp_dir, *repo_tmp_dir;
/* Create the temporary directory for the repository */
tmp_dir = g_file_new_for_path(tmpl);
repo_tmp_dir = g_file_get_child(tmp_dir, this->get_name ());
g_file_make_directory(repo_tmp_dir, 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 */
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[1] = g_build_filename(tmpl,
this->get_name (),
"IndexFile",
NULL);
source_dest[2] = NULL;
nullptr);
source_dest[2] = nullptr;
/* 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);
}
@@ -55,7 +60,7 @@ Dl::collect_cache_info (const gchar *tmpl) noexcept
/**
* slack::Dl::generate_cache:
* @job: A #PkBackendJob.
* @job_data: A #JobData.
* @tmpl: temporary directory for downloading the files.
*
* 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.
**/
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;
gboolean skip = FALSE;
char **line_tokens, **pkg_tokens, *line, *collection_name = nullptr, *list_filename;
bool skip = false;
GFile *list_file;
GFileInputStream *fin;
GDataInputStream *data_in = NULL;
sqlite3_stmt *stmt = NULL;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
GDataInputStream *data_in = nullptr;
sqlite3_stmt *stmt = nullptr;
/* Check if the temporary directory for this repository exists. If so the file metadata have to be generated */
list_filename = g_build_filename(tmpl,
this->get_name (),
"IndexFile",
NULL);
nullptr);
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;
}
@@ -91,7 +95,7 @@ Dl::generate_cache(PkBackendJob *job, const gchar *tmpl) noexcept
"DELETE FROM repos WHERE repo LIKE @repo",
-1,
&stmt,
NULL) == SQLITE_OK) {
nullptr) == SQLITE_OK) {
sqlite3_bind_text(stmt, 1, this->get_name (), -1, SQLITE_TRANSIENT);
sqlite3_step(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)",
-1,
&stmt,
NULL) != SQLITE_OK)
nullptr) != SQLITE_OK)
{
goto out;
}
@@ -120,13 +124,13 @@ Dl::generate_cache(PkBackendJob *job, const gchar *tmpl) noexcept
"@desc, @compressed, @uncompressed, @cat, @repo_order, @ext)",
-1,
&stmt,
NULL) != SQLITE_OK))
nullptr) != SQLITE_OK))
{
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);
if ((g_strv_length(line_tokens) > 6)
@@ -158,11 +162,11 @@ Dl::generate_cache(PkBackendJob *job, const gchar *tmpl) noexcept
}
else
{
skip = TRUE; /* Skip other candidates for collections */
skip = true; /* Skip other candidates for collections */
}
if (skip)
{
skip = FALSE;
skip = false;
}
else
{
@@ -186,15 +190,15 @@ Dl::generate_cache(PkBackendJob *job, const gchar *tmpl) noexcept
}
/* 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,
"INSERT INTO collections (name, repo_order, collection_pkg) "
"VALUES (@name, @repo_order, @collection_pkg)",
-1,
&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);
if ((g_strv_length(line_tokens) > 6)
@@ -221,7 +225,7 @@ Dl::generate_cache(PkBackendJob *job, const gchar *tmpl) noexcept
}
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:
if (data_in)
@@ -260,19 +264,19 @@ Dl::~Dl () noexcept
*
* Return value: New #slack::Dl.
**/
Dl::Dl (const gchar *name, const gchar *mirror,
guint8 order, const gchar *blacklist, gchar *index_file) noexcept
Dl::Dl (const char *name, const char *mirror,
std::uint8_t order, const char *blacklist, char *index_file) noexcept
{
GRegex *regex;
if (blacklist)
{
regex = static_cast<GRegex *> (g_regex_new (blacklist,
G_REGEX_OPTIMIZE, static_cast<GRegexMatchFlags> (0), NULL));
G_REGEX_OPTIMIZE, static_cast<GRegexMatchFlags> (0), nullptr));
}
else
{
regex = NULL;
regex = nullptr;
}
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 "utils.h"
namespace slack {
class Dl final : public Pkgtools
{
public:
Dl (const gchar *name, const gchar *mirror,
guint8 order, const gchar *blacklist, gchar *index_file) noexcept;
Dl (const char *name, const char *mirror,
std::uint8_t order, const char *blacklist, char *index_file) noexcept;
~Dl () noexcept;
GSList *collect_cache_info (const gchar *tmpl) noexcept;
void generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept;
GSList *collect_cache_info (const char *tmpl) noexcept;
void generate_cache (JobData *job_data, const char *tmpl) noexcept;
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 <string>
@@ -51,42 +56,42 @@ generate_query(PkBitfield filters)
}
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));
pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
pk_backend_job_set_percentage (job, 0);
gchar **vals;
char **vals;
PkBitfield filters;
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);
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 */
while (sqlite3_step (stmt) == SQLITE_ROW)
{
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)
&& slack::filter_package (filters, true))
{
pk_backend_job_package (job, PK_INFO_ENUM_INSTALLED,
reinterpret_cast<const gchar *> (sqlite3_column_text (stmt, 0)),
reinterpret_cast<const gchar *> (sqlite3_column_text (stmt, 1)));
reinterpret_cast<const char *> (sqlite3_column_text (stmt, 0)),
reinterpret_cast<const char *> (sqlite3_column_text (stmt, 1)));
}
else if (info == PK_INFO_ENUM_INSTALLING && slack::filter_package (filters, false))
{
pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE,
reinterpret_cast<const gchar *> (sqlite3_column_text (stmt, 0)),
reinterpret_cast<const gchar *> (sqlite3_column_text (stmt, 1)));
reinterpret_cast<const char *> (sqlite3_column_text (stmt, 0)),
reinterpret_cast<const char *> (sqlite3_column_text (stmt, 1)));
}
}
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 <sqlite3.h>
@@ -12,8 +16,6 @@ bool filter_package (PkBitfield filters, bool is_installed);
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 <glib/gstdio.h>
#include <packagekit-glib2/pk-debug.h>
#include <cstdint>
#include <stdlib.h>
#include <stdio.h>
#include <zlib.h>
@@ -15,19 +21,19 @@
using namespace slack;
static GSList *repos = NULL;
static GSList *repos = nullptr;
void pk_backend_initialize(GKeyFile *conf, PkBackend *backend)
{
gchar *path, **groups;
gint ret;
char *path, **groups;
int ret;
gushort i;
gsize groups_len;
GFile *conf_file;
GFileInfo *file_info;
GKeyFile *key_conf;
GError *err = NULL;
gpointer repo = NULL;
GError *err = nullptr;
void *repo = nullptr;
sqlite3 *db;
sqlite3_stmt *stmt;
@@ -35,7 +41,7 @@ void pk_backend_initialize(GKeyFile *conf, PkBackend *backend)
curl_global_init(CURL_GLOBAL_DEFAULT);
/* Open the database. We will need it to save the time the configuration file was last modified. */
path = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", NULL);
path = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", nullptr);
if (sqlite3_open(path, &db) != SQLITE_OK)
{
g_error("%s: %s", path, sqlite3_errmsg(db));
@@ -44,7 +50,7 @@ void pk_backend_initialize(GKeyFile *conf, PkBackend *backend)
/* Read the configuration file */
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);
if (err)
{
@@ -56,7 +62,7 @@ void pk_backend_initialize(GKeyFile *conf, PkBackend *backend)
if (!(file_info = g_file_query_info(conf_file,
"time::modified-usec",
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL,
nullptr,
&err)))
{
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'",
-1,
&stmt,
NULL)) == SQLITE_OK) {
nullptr)) == SQLITE_OK) {
ret = sqlite3_bind_int(stmt, 1, g_file_info_get_attribute_uint32(file_info, "time::modified-usec"));
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);
for (i = 0; i < groups_len; i++)
{
gchar *blacklist = g_key_file_get_string(key_conf, groups[i], "Blacklist", NULL);
gchar *mirror = g_key_file_get_string(key_conf, groups[i], "Mirror", NULL);
char *blacklist = g_key_file_get_string(key_conf, groups[i], "Blacklist", nullptr);
char *mirror = g_key_file_get_string(key_conf, groups[i], "Mirror", nullptr);
if (g_key_file_has_key(key_conf, groups[i], "Priority", NULL))
if (g_key_file_has_key(key_conf, groups[i], "Priority", nullptr))
{
repo = new Slackpkg (groups[i], mirror, i + 1, blacklist,
g_key_file_get_string_list(key_conf, groups[i], "Priority", 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,
g_key_file_get_string(key_conf, groups[i], "IndexFile", NULL));
g_key_file_get_string(key_conf, groups[i], "IndexFile", nullptr));
}
if (repo)
@@ -137,71 +143,18 @@ pk_backend_destroy(PkBackend *backend)
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
pk_backend_start_job(PkBackend *backend, PkBackendJob *job)
{
gchar *db_filename = NULL;
char *db_filename = nullptr;
JobData *job_data = g_new0(JobData, 1);
pk_backend_job_set_allow_cancel(job, TRUE);
pk_backend_job_set_allow_cancel(job, FALSE);
pk_backend_job_set_allow_cancel(job, true);
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 */
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
{
@@ -231,32 +184,32 @@ pk_backend_stop_job(PkBackend *backend, PkBackendJob *job)
sqlite3_close(job_data->db);
g_free(job_data);
pk_backend_job_set_user_data(job, NULL);
pk_backend_job_set_user_data(job, nullptr);
}
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
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
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
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;
gchar *query;
char **vals, *search;
char *query;
sqlite3_stmt *stmt;
PkInfoEnum ret;
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_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);
query = sqlite3_mprintf("SELECT (p.name || ';' || p.ver || ';' || p.arch || ';' || r.repo), p.summary, "
"p.full_name FROM filelist AS f NATURAL JOIN pkglist AS p NATURAL JOIN repos AS r "
"WHERE f.filename LIKE '%%%q%%' GROUP BY f.full_name", search);
if ((sqlite3_prepare_v2(job_data->db, query, -1, &stmt, NULL) == SQLITE_OK))
if ((sqlite3_prepare_v2(job_data->db, query, -1, &stmt, nullptr) == SQLITE_OK))
{
/* Now we're ready to output all packages */
while (sqlite3_step(stmt) == SQLITE_ROW)
{
ret = is_installed((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))
{
pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED,
(gchar*) sqlite3_column_text(stmt, 0),
(gchar*) sqlite3_column_text(stmt, 1));
(char*) sqlite3_column_text(stmt, 0),
(char*) sqlite3_column_text(stmt, 1));
}
else if (ret == PK_INFO_ENUM_INSTALLING)
{
pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE,
(gchar*) sqlite3_column_text(stmt, 0),
(gchar*) sqlite3_column_text(stmt, 1));
(char*) sqlite3_column_text(stmt, 0),
(char*) sqlite3_column_text(stmt, 1));
}
}
sqlite3_finalize(stmt);
@@ -303,21 +256,21 @@ pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, gpointer use
}
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
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;
gchar** tokens;
char **pkg_ids, *homepage = nullptr;
char** tokens;
gsize i;
GString *desc;
GRegex *expr;
GMatchInfo *match_info;
GError *err = NULL;
GError *err = nullptr;
sqlite3_stmt *stmt;
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'",
-1,
&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));
goto out;
}
@@ -343,7 +296,7 @@ pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, gpointer user
if (sqlite3_step(stmt) != SQLITE_ROW)
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 */
expr = g_regex_new("(?:http|ftp):\\/\\/[[:word:]\\/\\-\\.]+[[:word:]\\/](?=\\.?$)",
@@ -375,9 +328,9 @@ pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, gpointer user
/* Ready */
pk_backend_job_details(job,
pkg_ids[0],
NULL,
NULL,
pk_group_enum_from_string((gchar *) sqlite3_column_text(stmt, 1)),
nullptr,
nullptr,
pk_group_enum_from_string((char *) sqlite3_column_text(stmt, 1)),
desc->str,
homepage,
sqlite3_column_int(stmt, 2),
@@ -386,7 +339,7 @@ pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, gpointer user
g_free(homepage);
if (desc)
{
g_string_free(desc, TRUE);
g_string_free(desc, true);
}
out:
@@ -394,15 +347,15 @@ out:
}
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
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;
PkInfoEnum ret;
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_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,
"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)",
-1,
&stmt,
NULL) == SQLITE_OK)) {
nullptr) == SQLITE_OK)) {
/* Output packages matching each pattern */
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)
{
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))
{
pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED,
(gchar*) sqlite3_column_text(stmt, 0),
(gchar*) sqlite3_column_text(stmt, 1));
(char*) sqlite3_column_text(stmt, 0),
(char*) sqlite3_column_text(stmt, 1));
}
else if (ret == PK_INFO_ENUM_INSTALLING)
{
pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE,
(gchar*) sqlite3_column_text(stmt, 0),
(gchar*) sqlite3_column_text(stmt, 1));
(char*) sqlite3_column_text(stmt, 0),
(char*) sqlite3_column_text(stmt, 1));
}
}
@@ -454,16 +407,16 @@ pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, gpointer user_dat
}
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
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};
guint i;
char *dir_path, *path, **pkg_ids, *to_strv[] = {nullptr, nullptr};
unsigned i;
sqlite3_stmt *stmt;
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",
-1,
&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));
goto out;
@@ -483,7 +436,7 @@ pk_backend_download_packages_thread(PkBackendJob *job, GVariant *params, gpointe
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, 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,
pkg_ids[i],
(gchar *) sqlite3_column_text(stmt, 0));
(char *) sqlite3_column_text(stmt, 0));
static_cast<Pkgtools *> (repo->data)->download (job,
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;
pk_backend_job_files(job, NULL, to_strv);
pk_backend_job_files(job, nullptr, to_strv);
g_free(path);
}
}
@@ -515,20 +468,20 @@ out:
}
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
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;
gchar **pkg_ids;
guint i;
char *dest_dir_name;
char **pkg_ids;
unsigned i;
gdouble percent_step;
GSList *install_list = NULL, *l;
sqlite3_stmt *pkglist_stmt = NULL, *collection_stmt = NULL;
GSList *install_list = nullptr, *l;
sqlite3_stmt *pkglist_stmt = nullptr, *collection_stmt = nullptr;
PkBitfield transaction_flags = 0;
PkInfoEnum ret;
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",
-1,
&pkglist_stmt,
NULL) != SQLITE_OK) ||
nullptr) != SQLITE_OK) ||
(sqlite3_prepare_v2(job_data->db,
"SELECT (c.collection_pkg || ';' || p.ver || ';' || p.arch || ';' || r.repo), p.summary, "
"p.full_name, p.ext FROM collections AS c "
@@ -550,7 +503,7 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, gpointer
"WHERE c.name LIKE @name AND r.repo LIKE @repo",
-1,
&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));
goto out;
@@ -558,7 +511,7 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, gpointer
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, 2, tokens[PK_PACKAGE_ID_VERSION], -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 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))
{
pk_backend_job_package(job, PK_INFO_ENUM_INSTALLING,
pkg_ids[i],
(gchar *) sqlite3_column_text(pkglist_stmt, 0));
(char *) sqlite3_column_text(pkglist_stmt, 0));
}
else
{
@@ -587,24 +540,24 @@ pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, gpointer
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 ((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 */
}
else if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE))
{
pk_backend_job_package(job, ret,
(gchar *) sqlite3_column_text(collection_stmt, 0),
(gchar *) sqlite3_column_text(collection_stmt, 1));
(char *) sqlite3_column_text(collection_stmt, 0),
(char *) sqlite3_column_text(collection_stmt, 1));
}
else
{
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 */
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++)
{
gchar **tokens;
char **tokens;
GSList *repo;
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);
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);
for (l = install_list; l; l = g_slist_next(l), i++)
{
gchar **tokens;
char **tokens;
GSList *repo;
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);
if (repo)
@@ -673,19 +626,19 @@ void
pk_backend_install_packages(PkBackend *backend,
PkBackendJob *job,
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
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;
guint i;
char **pkg_ids, *cmd_line;
unsigned i;
gdouble percent_step;
gboolean allow_deps, autoremove;
GError *err = NULL;
bool allow_deps, autoremove;
GError *err = nullptr;
PkBitfield transaction_flags = 0;
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);
for (i = 0; pkg_ids[i]; i++)
{
gchar **tokens;
char **tokens;
pk_backend_job_set_percentage(job, percent_step * 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 */
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_strfreev(tokens);
@@ -731,22 +684,22 @@ void
pk_backend_remove_packages(PkBackend *backend,
PkBackendJob *job,
PkBitfield transaction_flags,
gchar **package_ids,
gboolean allow_deps,
gboolean autoremove)
char **package_ids,
bool allow_deps,
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
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;
const gchar *pkg_metadata_filename;
char *pkg_id, *full_name, *desc;
const char *pkg_metadata_filename;
GFile *pkg_metadata_dir;
GFileEnumerator *pkg_metadata_enumerator;
GFileInfo *pkg_metadata_file_info;
GError *err = NULL;
GError *err = nullptr;
sqlite3_stmt *stmt;
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)",
-1,
&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));
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_enumerator = g_file_enumerate_children(pkg_metadata_dir, "standard::name",
G_FILE_QUERY_INFO_NONE,
NULL,
nullptr,
&err);
g_object_unref(pkg_metadata_dir);
if (err)
@@ -779,9 +732,9 @@ pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user
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);
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
* repository with the lowest order. */
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 */
pkg_id = pk_package_id_build(tokens[PK_PACKAGE_ID_NAME],
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()
if the package is obsolete or not
* 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);
@@ -816,11 +769,11 @@ pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user
}
else if (g_strcmp0(pkg_metadata_filename, full_name))
{ /* Update available */
pkg_id = pk_package_id_build((gchar *) sqlite3_column_text(stmt, 1),
(gchar *) sqlite3_column_text(stmt, 2),
(gchar *) sqlite3_column_text(stmt, 3),
(gchar *) sqlite3_column_text(stmt, 4));
desc = g_strdup((gchar *) sqlite3_column_text(stmt, 5));
pkg_id = pk_package_id_build((char *) sqlite3_column_text(stmt, 1),
(char *) sqlite3_column_text(stmt, 2),
(char *) sqlite3_column_text(stmt, 3),
(char *) sqlite3_column_text(stmt, 4));
desc = g_strdup((char *) sqlite3_column_text(stmt, 5));
pk_backend_job_package(job, PK_INFO_ENUM_NORMAL, pkg_id, desc);
@@ -845,14 +798,14 @@ out:
void
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
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;
guint i;
char *dest_dir_name, *cmd_line, **pkg_ids;
unsigned i;
PkBitfield transaction_flags = 0;
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);
/* 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++)
{
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"))
{
@@ -885,7 +838,7 @@ pk_backend_update_packages_thread(PkBackendJob *job, GVariant *params, gpointer
pk_backend_job_set_status(job, PK_STATUS_ENUM_UPDATE);
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"))
{
@@ -901,8 +854,8 @@ pk_backend_update_packages_thread(PkBackendJob *job, GVariant *params, gpointer
{
/* Remove obsolete package
* TODO: Removing should be an independent operation (not during installing updates) */
cmd_line = g_strconcat("/sbin/removepkg ", tokens[PK_PACKAGE_ID_NAME], NULL);
g_spawn_command_line_sync(cmd_line, NULL, NULL, NULL, NULL);
cmd_line = g_strconcat("/sbin/removepkg ", tokens[PK_PACKAGE_ID_NAME], nullptr);
g_spawn_command_line_sync(cmd_line, nullptr, nullptr, nullptr, nullptr);
g_free(cmd_line);
}
g_strfreev(tokens);
@@ -914,22 +867,22 @@ void
pk_backend_update_packages(PkBackend *backend,
PkBackendJob *job,
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
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;
gint ret;
gboolean force;
GSList *file_list = NULL;
GFile *db_file = NULL;
GFileInfo *file_info = NULL;
GError *err = NULL;
sqlite3_stmt *stmt = NULL;
char *tmp_dir_name, *db_err, *path = nullptr;
int ret;
bool force;
GSList *file_list = nullptr;
GFile *db_file = nullptr;
GFileInfo *file_info = nullptr;
GError *err = nullptr;
sqlite3_stmt *stmt = nullptr;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
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 */
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);
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)
{
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'",
-1,
&stmt,
NULL);
nullptr);
if ((ret != SQLITE_OK) || ((ret = sqlite3_step(stmt)) != SQLITE_ROW))
{
pk_backend_job_error_code(job,
@@ -971,14 +924,14 @@ pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, gpointer us
sqlite3_errstr(ret));
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 (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);
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))
{
get_file(&job_data->curl, static_cast<gchar **> (l->data)[0],
static_cast<gchar **> (l->data)[1]);
get_file(&job_data->curl, static_cast<char **> (l->data)[0],
static_cast<char **> (l->data)[1]);
}
g_slist_free_full(file_list, (GDestroyNotify)g_strfreev);
@@ -1029,43 +982,43 @@ out:
}
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
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;
gchar **pkg_ids;
unsigned i;
char **pkg_ids;
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
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,
pkg_ids[i],
NULL,
NULL,
NULL,
NULL,
NULL,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
PK_RESTART_ENUM_NONE,
NULL,
NULL,
nullptr,
nullptr,
PK_UPDATE_STATE_ENUM_STABLE,
NULL,
NULL);
nullptr,
nullptr);
}
}
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

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

167
backend/slackpkg.cc
View File

@@ -7,7 +7,7 @@
namespace slack {
GHashTable *Slackpkg::cat_map = NULL;
GHashTable *Slackpkg::cat_map = nullptr;
/*
* slack::Slackpkg::manifest:
@@ -19,24 +19,24 @@ GHashTable *Slackpkg::cat_map = NULL;
*/
void
Slackpkg::manifest (PkBackendJob *job,
const gchar *tmpl, gchar *filename) noexcept
const char *tmpl, char *filename) noexcept
{
FILE *manifest;
gint err, read_len;
guint pos;
gchar buf[max_buf_size], *path, *pkg_filename, *rest = NULL, *start;
gchar *full_name = NULL;
gchar **line, **lines;
int err, read_len;
unsigned pos;
char buf[max_buf_size], *path, *pkg_filename, *rest = nullptr, *start;
char *full_name = nullptr;
char **line, **lines;
BZFILE *manifest_bz2;
GRegex *pkg_expr = NULL, *file_expr = NULL;
GRegex *pkg_expr = nullptr, *file_expr = nullptr;
GMatchInfo *match_info;
sqlite3_stmt *statement = NULL;
sqlite3_stmt *statement = nullptr;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
path = g_build_filename(tmpl,
this->get_name (),
filename,
NULL);
nullptr);
manifest = fopen(path, "rb");
g_free(path);
@@ -44,7 +44,7 @@ Slackpkg::manifest (PkBackendJob *job,
{
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;
}
@@ -53,14 +53,14 @@ Slackpkg::manifest (PkBackendJob *job,
pkg_expr = g_regex_new("^\\|\\|[[:blank:]]+Package:[[:blank:]]+.+\\/(.+)\\.(t[blxg]z$)?",
static_cast<GRegexCompileFlags> (G_REGEX_OPTIMIZE | G_REGEX_DUPNAMES),
static_cast<GRegexMatchFlags> (0),
NULL);
nullptr);
file_expr = g_regex_new("^[-bcdlps][-r][-w][-xsS][-r][-w][-xsS][-r][-w]"
"[-xtT][[:space:]][^[:space:]]+[[:space:]]+"
"[[:digit:]]+[[:space:]][[:digit:]-]+[[:space:]]"
"[[:digit:]:]+[[:space:]](?!install\\/|\\.)(.*)",
static_cast<GRegexCompileFlags> (G_REGEX_OPTIMIZE | G_REGEX_DUPNAMES),
static_cast<GRegexMatchFlags> (0),
NULL);
nullptr);
if (!(file_expr) || !(pkg_expr))
{
goto out;
@@ -71,12 +71,12 @@ Slackpkg::manifest (PkBackendJob *job,
"INSERT INTO filelist (full_name, filename) VALUES (@full_name, @filename)",
-1,
&statement,
NULL) != SQLITE_OK)
nullptr) != SQLITE_OK)
{
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)))
{
if ((err != BZ_OK) && (err != BZ_STREAM_END))
@@ -90,7 +90,7 @@ Slackpkg::manifest (PkBackendJob *job,
if (rest)
{ /* Add to the first line rest characters from the previous read operation */
start = lines[0];
lines[0] = g_strconcat(rest, lines[0], NULL);
lines[0] = g_strconcat(rest, lines[0], nullptr);
g_free(start);
g_free(rest);
}
@@ -98,7 +98,7 @@ Slackpkg::manifest (PkBackendJob *job,
{
pos = g_strv_length(lines) - 1;
rest = lines[pos];
lines[pos] = NULL;
lines[pos] = nullptr;
}
for (line = lines; *line; line++)
{
@@ -111,12 +111,12 @@ Slackpkg::manifest (PkBackendJob *job,
}
else
{
full_name = NULL;
full_name = nullptr;
}
}
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))
{
pkg_filename = g_match_info_fetch(match_info, 1);
@@ -132,7 +132,7 @@ Slackpkg::manifest (PkBackendJob *job,
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);
BZ2_bzReadClose(&err, manifest_bz2);
@@ -159,33 +159,33 @@ out:
* Returns: List of files needed for building the cache.
**/
GSList *
Slackpkg::collect_cache_info (const gchar *tmpl) noexcept
Slackpkg::collect_cache_info (const char *tmpl) noexcept
{
CURL *curl = NULL;
gchar **source_dest;
GSList *file_list = NULL;
CURL *curl = nullptr;
char **source_dest;
GSList *file_list = nullptr;
GFile *tmp_dir, *repo_tmp_dir;
/* Create the temporary directory for the repository */
tmp_dir = g_file_new_for_path(tmpl);
repo_tmp_dir = g_file_get_child(tmp_dir, this->get_name ());
g_file_make_directory(repo_tmp_dir, 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 */
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 (),
*cur_priority,
"/PACKAGES.TXT",
NULL);
nullptr);
source_dest[1] = g_build_filename(tmpl,
this->get_name (),
"PACKAGES.TXT",
NULL);
source_dest[2] = NULL;
nullptr);
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);
}
@@ -197,17 +197,17 @@ Slackpkg::collect_cache_info (const gchar *tmpl) noexcept
}
/* 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 (),
*cur_priority,
"/MANIFEST.bz2",
NULL);
nullptr);
source_dest[1] = g_strconcat(tmpl,
"/", this->get_name (),
"/", *cur_priority, "-MANIFEST.bz2",
NULL);
source_dest[2] = NULL;
if (get_file(&curl, source_dest[0], NULL) == CURLE_OK)
nullptr);
source_dest[2] = nullptr;
if (get_file(&curl, source_dest[0], nullptr) == CURLE_OK)
{
file_list = g_slist_prepend(file_list, source_dest);
}
@@ -229,7 +229,7 @@ out:
/**
* slack::Slackpkg::generate_cache:
* @job: A #PkBackendJob.
* @job_data: A #JobData.
* @tmpl: temporary directory for downloading the files.
*
* 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.
**/
void
Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
Slackpkg::generate_cache (JobData *job_data, const char *tmpl) noexcept
{
gchar **pkg_tokens = NULL;
gchar *query = NULL, *filename = NULL, *location = NULL, *summary = NULL, *line, *packages_txt;
guint pkg_compressed = 0, pkg_uncompressed = 0;
char **pkg_tokens = nullptr;
char *query = nullptr, *filename = nullptr, *location = nullptr, *summary = nullptr, *line, *packages_txt;
unsigned pkg_compressed = 0, pkg_uncompressed = 0;
gushort pkg_name_len;
GString *desc;
GFile *list_file;
GFileInputStream *fin = NULL;
GDataInputStream *data_in = NULL;
sqlite3_stmt *insert_statement = NULL, *update_statement = NULL, *insert_default_statement = NULL, *statement;
auto job_data = static_cast<JobData *> (pk_backend_job_get_user_data(job));
GFileInputStream *fin = nullptr;
GDataInputStream *data_in = nullptr;
sqlite3_stmt *insert_statement = nullptr, *update_statement = nullptr, *insert_default_statement = nullptr, *statement;
/* Check if the temporary directory for this repository exists, then the file metadata have to be generated */
packages_txt = g_build_filename(tmpl,
this->get_name (),
"PACKAGES.TXT",
NULL);
nullptr);
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_free(packages_txt);
if (!fin)
@@ -269,7 +268,7 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
"DELETE FROM repos WHERE repo LIKE @repo",
-1,
&statement,
NULL) == SQLITE_OK)
nullptr) == SQLITE_OK)
{
sqlite3_bind_text(statement,
1,
@@ -283,7 +282,7 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
"INSERT INTO repos (repo_order, repo) VALUES (@repo_order, @repo)",
-1,
&statement,
NULL) != SQLITE_OK)
nullptr) != SQLITE_OK)
{
goto out;
}
@@ -304,7 +303,7 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
"@desc, @compressed, @uncompressed, @name, @repo_order, @cat)",
-1,
&insert_statement,
NULL) != SQLITE_OK)
nullptr) != SQLITE_OK)
|| (sqlite3_prepare_v2(job_data->db,
"INSERT OR REPLACE INTO pkglist (full_name, ver, arch, ext, location, "
"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)",
-1,
&insert_default_statement,
NULL) != SQLITE_OK))
nullptr) != SQLITE_OK))
{
goto out;
}
@@ -321,7 +320,7 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
"desc = @desc, compressed = @compressed, uncompressed = @uncompressed "
"WHERE name LIKE @name AND repo_order = %u",
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;
}
@@ -329,9 +328,9 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
data_in = g_data_input_stream_new(G_INPUT_STREAM(fin));
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))
{
@@ -339,7 +338,7 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
if (this->is_blacklisted (filename))
{
g_free(filename);
filename = NULL;
filename = nullptr;
}
}
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:"))
{
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, "(");
if (summary) /* Else summary = NULL */
if (summary) /* Else summary = nullptr */
{
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 */
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));
}
@@ -418,21 +417,21 @@ Slackpkg::generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept
g_free(filename);
g_free(location);
g_free(summary);
filename = location = summary = NULL;
filename = location = summary = nullptr;
g_string_assign(desc, "");
pkg_compressed = pkg_uncompressed = 0;
}
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);
/* 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);
g_free(filename);
}
@@ -475,19 +474,19 @@ Slackpkg::~Slackpkg () noexcept
*
* Returns: New #slack::Slackpkg.
**/
Slackpkg::Slackpkg (const gchar *name, const gchar *mirror,
guint8 order, const gchar *blacklist, gchar **priority) noexcept
Slackpkg::Slackpkg (const char *name, const char *mirror,
std::uint8_t order, const char *blacklist, char **priority) noexcept
{
GRegex *regex;
if (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
{
regex = NULL;
regex = nullptr;
}
this->name = g_strdup (name);
@@ -500,25 +499,25 @@ Slackpkg::Slackpkg (const gchar *name, const gchar *mirror,
this->priority = priority;
// Initialize category map
if (cat_map == NULL)
if (cat_map == nullptr)
{
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, (gpointer) "ap", (gpointer) "admin-tools");
g_hash_table_insert (cat_map, (gpointer) "d", (gpointer) "programming");
g_hash_table_insert (cat_map, (gpointer) "e", (gpointer) "programming");
g_hash_table_insert (cat_map, (gpointer) "f", (gpointer) "documentation");
g_hash_table_insert (cat_map, (gpointer) "k", (gpointer) "system");
g_hash_table_insert (cat_map, (gpointer) "kde", (gpointer) "desktop-kde");
g_hash_table_insert (cat_map, (gpointer) "kdei", (gpointer) "localization");
g_hash_table_insert (cat_map, (gpointer) "l", (gpointer) "system");
g_hash_table_insert (cat_map, (gpointer) "n", (gpointer) "network");
g_hash_table_insert (cat_map, (gpointer) "t", (gpointer) "publishing");
g_hash_table_insert (cat_map, (gpointer) "tcl", (gpointer) "system");
g_hash_table_insert (cat_map, (gpointer) "x", (gpointer) "desktop-other");
g_hash_table_insert (cat_map, (gpointer) "xap", (gpointer) "accessories");
g_hash_table_insert (cat_map, (gpointer) "xfce", (gpointer) "desktop-xfce");
g_hash_table_insert (cat_map, (gpointer) "y", (gpointer) "games");
g_hash_table_insert (cat_map, (void *) "a", (void *) "system");
g_hash_table_insert (cat_map, (void *) "ap", (void *) "admin-tools");
g_hash_table_insert (cat_map, (void *) "d", (void *) "programming");
g_hash_table_insert (cat_map, (void *) "e", (void *) "programming");
g_hash_table_insert (cat_map, (void *) "f", (void *) "documentation");
g_hash_table_insert (cat_map, (void *) "k", (void *) "system");
g_hash_table_insert (cat_map, (void *) "kde", (void *) "desktop-kde");
g_hash_table_insert (cat_map, (void *) "kdei", (void *) "localization");
g_hash_table_insert (cat_map, (void *) "l", (void *) "system");
g_hash_table_insert (cat_map, (void *) "n", (void *) "network");
g_hash_table_insert (cat_map, (void *) "t", (void *) "publishing");
g_hash_table_insert (cat_map, (void *) "tcl", (void *) "system");
g_hash_table_insert (cat_map, (void *) "x", (void *) "desktop-other");
g_hash_table_insert (cat_map, (void *) "xap", (void *) "accessories");
g_hash_table_insert (cat_map, (void *) "xfce", (void *) "desktop-xfce");
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 "pkgtools.h"
#include "utils.h"
namespace slack {
class Slackpkg final : public Pkgtools
{
public:
Slackpkg (const gchar *name, const gchar *mirror,
guint8 order, const gchar *blacklist, gchar **priority) noexcept;
Slackpkg (const char *name, const char *mirror,
std::uint8_t order, const char *blacklist, char **priority) noexcept;
~Slackpkg () noexcept;
GSList *collect_cache_info (const gchar *tmpl) noexcept;
void generate_cache (PkBackendJob *job, const gchar *tmpl) noexcept;
GSList *collect_cache_info (const char *tmpl) noexcept;
void generate_cache (JobData *job_data, const char *tmpl) noexcept;
private:
static GHashTable *cat_map;
static const std::size_t max_buf_size = 8192;
gchar **priority = NULL;
char **priority = nullptr;
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-job.h>
gpointer
void *
pk_backend_job_get_user_data (PkBackendJob *job)
{
return NULL;
return nullptr;
}
void
pk_backend_job_set_user_data (PkBackendJob *job, gpointer user_data)
pk_backend_job_set_user_data (PkBackendJob *job, void *user_data)
{
}
void
pk_backend_job_set_allow_cancel (PkBackendJob *job, gboolean allow_cancel)
pk_backend_job_set_allow_cancel (PkBackendJob *job, bool allow_cancel)
{
}
void
pk_backend_job_package (PkBackendJob *job,
PkInfoEnum info,
const gchar *package_id,
const gchar *summary)
const char *package_id,
const char *summary)
{
}
@@ -31,62 +37,62 @@ pk_backend_job_set_status (PkBackendJob *job, PkStatusEnum status)
}
void
pk_backend_job_set_percentage (PkBackendJob *job, guint percentage)
pk_backend_job_set_percentage (PkBackendJob *job, unsigned percentage)
{
}
void
pk_backend_job_error_code (PkBackendJob *job,
PkErrorEnum error_code, const gchar *format, ...)
PkErrorEnum error_code, const char *format, ...)
{
}
void
pk_backend_job_files (PkBackendJob *job,
const gchar *package_id, gchar **files)
const char *package_id, char **files)
{
}
void
pk_backend_job_details (PkBackendJob *job,
const gchar *package_id,
const gchar *summary,
const gchar *license,
const char *package_id,
const char *summary,
const char *license,
PkGroupEnum group,
const gchar *description,
const gchar *url,
gulong size,
guint64 download_size)
const char *description,
const char *url,
unsigned long size,
std::uint64_t download_size)
{
}
void
pk_backend_job_update_detail (PkBackendJob *job,
const gchar *package_id,
gchar **updates,
gchar **obsoletes,
gchar **vendor_urls,
gchar **bugzilla_urls,
gchar **cve_urls,
const char *package_id,
char **updates,
char **obsoletes,
char **vendor_urls,
char **bugzilla_urls,
char **cve_urls,
PkRestartEnum restart,
const gchar *update_text,
const gchar *changelog,
const char *update_text,
const char *changelog,
PkUpdateStateEnum state,
const gchar *issued,
const gchar *updated)
const char *issued,
const char *updated)
{
}
gboolean
bool
pk_backend_job_thread_create (PkBackendJob *job,
PkBackendJobThreadFunc func,
gpointer user_data,
void *user_data,
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"
using namespace slack;
@@ -5,7 +10,7 @@ using namespace slack;
static void
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_mirror (), ==, "mirror");
@@ -17,7 +22,7 @@ slack_test_dl_construct()
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);

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"
using namespace slack;
@@ -5,7 +10,7 @@ using namespace slack;
static void
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_mirror (), ==, "mirror");
@@ -17,7 +22,7 @@ slack_test_slackpkg_construct()
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);

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 <string.h>
#include "utils.h"
@@ -16,14 +22,14 @@ namespace slack {
* Returns: CURLE_OK (zero) on success, non-zero otherwise.
**/
CURLcode
get_file (CURL **curl, gchar *source_url, gchar *dest)
get_file (CURL **curl, char *source_url, char *dest)
{
gchar *dest_dir_name;
FILE *fout = NULL;
char *dest_dir_name;
FILE *fout = nullptr;
CURLcode ret;
glong response_code;
if ((*curl == NULL) && (!(*curl = curl_easy_init())))
if ((*curl == nullptr) && (!(*curl = curl_easy_init())))
{
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_URL, source_url);
if (dest == NULL)
if (dest == nullptr)
{
curl_easy_setopt(*curl, CURLOPT_NOBODY, 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))
{
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);
}
if ((fout = fopen(dest, "ab")) == NULL)
if ((fout = fopen(dest, "ab")) == nullptr)
{
return CURLE_WRITE_ERROR;
}
@@ -59,7 +65,7 @@ get_file (CURL **curl, gchar *source_url, gchar *dest)
ret = curl_easy_perform(*curl);
}
curl_easy_reset(*curl);
if (fout != NULL)
if (fout != nullptr)
{
fclose(fout);
}
@@ -70,23 +76,23 @@ get_file (CURL **curl, gchar *source_url, gchar *dest)
* slack::split_package_name:
* Got the name of a package, without version-arch-release data.
**/
gchar **
split_package_name (const gchar *pkg_filename)
char **
split_package_name (const char *pkg_filename)
{
gchar *pkg_full_name;
gchar **pkg_tokens;
char *pkg_full_name;
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)
{
return NULL;
return nullptr;
}
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 */
len -= 4;
@@ -95,18 +101,18 @@ split_package_name (const gchar *pkg_filename)
/* The last 3 characters should be the file extension */
pkg_tokens[4] = g_strdup (pkg_filename + len + 1);
pkg_tokens[5] = NULL;
pkg_tokens[5] = nullptr;
}
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_tokens[3] = NULL;
pkg_tokens[3] = nullptr;
}
/* Reverse all of the bytes in the package filename to get the name, version and the architecture */
g_strreverse (pkg_full_name);
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[1] = g_strreverse (reversed_tokens[2]); /* Version */
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.
**/
PkInfoEnum
is_installed (const gchar *pkg_fullname)
is_installed (const char *pkg_fullname)
{
GFileEnumerator *pkg_metadata_enumerator;
GFileInfo *pkg_metadata_file_info;
GFile *pkg_metadata_dir;
PkInfoEnum ret = PK_INFO_ENUM_INSTALLING;
const gchar *it;
guint8 dashes = 0;
const char *it;
std::uint8_t dashes = 0;
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
// looking for.
@@ -169,16 +175,16 @@ is_installed (const gchar *pkg_fullname)
if (!(pkg_metadata_enumerator = g_file_enumerate_children(pkg_metadata_dir,
"standard::name",
G_FILE_QUERY_INFO_NONE,
NULL,
NULL)))
nullptr,
nullptr)))
{
g_object_unref(pkg_metadata_dir);
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;
if (strcmp(dir, pkg_fullname) == 0)
@@ -220,12 +226,12 @@ is_installed (const gchar *pkg_fullname)
/**
* slack::cmp_repo:
**/
gint
cmp_repo (gconstpointer a, gconstpointer b)
int
cmp_repo (const void *a, const void *b)
{
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 <pk-backend.h>
@@ -9,24 +13,20 @@ namespace slack {
struct JobData
{
GObjectClass parent_class;
sqlite3 *db;
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" {
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]
path = "/home/path/to/local/repository"
[slackware]
Mirror=http://mirrors.slackware.com/slackware/slackware64-15.0/
Priority=patches;@pkgmain@;extra;pasture;testing
#Blacklist=