src/libpakfire/include/pakfire/snapshot.h \
src/libpakfire/include/pakfire/solution.h \
src/libpakfire/include/pakfire/transaction.h \
- src/libpakfire/include/pakfire/types.h \
src/libpakfire/include/pakfire/ui.h \
src/libpakfire/include/pakfire/util.h
}
static PyObject* Archive_get_package(ArchiveObject* self) {
- Pakfire pakfire = pakfire_archive_get_pakfire(self->archive);
+ struct pakfire* pakfire = pakfire_archive_get_pakfire(self->archive);
struct pakfire_repo* repo = pakfire_get_repo(pakfire, "@dummy");
if (!repo)
return -1;
}
- Pakfire pakfire = pakfire_package_get_pakfire(self->package);
+ struct pakfire* pakfire = pakfire_package_get_pakfire(self->package);
// Create a new filelist
struct pakfire_filelist* filelist;
static PyObject* Pakfire_execute_logging_callback = NULL;
-static int __Pakfire_execute_logging_callback(Pakfire pakfire, void* data,
+static int __Pakfire_execute_logging_callback(struct pakfire* pakfire, void* data,
int priority, const char* line, size_t length) {
int r = 0;
typedef struct {
PyObject_HEAD
- Pakfire pakfire;
+ struct pakfire* pakfire;
PyObject* logger;
} PakfireObject;
if (!PyArg_ParseTuple(args, "sss", &name, &evr, &arch))
return NULL;
- Pakfire pakfire = pakfire_repo_get_pakfire(self->repo);
+ struct pakfire* pakfire = pakfire_repo_get_pakfire(self->repo);
struct pakfire_package* pkg = pakfire_package_create(pakfire, self->repo, name, evr, arch);
PyObject* obj = new_package(&PackageType, pkg);
#include <pakfire/package.h>
#include <pakfire/packagelist.h>
-#include <pakfire/types.h>
#include "package.h"
#include "util.h"
};
struct pakfire_archive {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
char path[PATH_MAX];
free(archive);
}
-static int pakfire_archive_create(struct pakfire_archive** archive, Pakfire pakfire) {
+static int pakfire_archive_create(struct pakfire_archive** archive, struct pakfire* pakfire) {
struct pakfire_archive* a = calloc(1, sizeof(*a));
if (!a)
return ENOMEM;
return NULL;
}
-PAKFIRE_EXPORT Pakfire pakfire_archive_get_pakfire(struct pakfire_archive* archive) {
+PAKFIRE_EXPORT struct pakfire* pakfire_archive_get_pakfire(struct pakfire_archive* archive) {
return pakfire_ref(archive->pakfire);
}
return r;
}
-PAKFIRE_EXPORT int pakfire_archive_open(struct pakfire_archive** archive, Pakfire pakfire, const char* path) {
+PAKFIRE_EXPORT int pakfire_archive_open(struct pakfire_archive** archive, struct pakfire* pakfire, const char* path) {
int r = pakfire_archive_create(archive, pakfire);
if (r)
return r;
return pakfire_filelist_ref(archive->filelist);
}
-static pakfire_archive_verify_status_t pakfire_archive_verify_file(Pakfire pakfire,
+static pakfire_archive_verify_status_t pakfire_archive_verify_file(struct pakfire* pakfire,
struct archive* a, const struct pakfire_archive_chksum* chksum) {
pakfire_archive_verify_status_t status = PAKFIRE_ARCHIVE_VERIFY_ERROR;
#include <pakfire/repo.h>
#include <pakfire/scriptlet.h>
#include <pakfire/snapshot.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
#define CCACHE_DIR "/var/cache/ccache"
"\n" \
"exit 0\n"
-static int pakfire_build_install_packages(Pakfire pakfire, int* snapshot_needs_update) {
+static int pakfire_build_install_packages(struct pakfire* pakfire, int* snapshot_needs_update) {
char** packages = NULL;
int r = 1;
return r;
}
-int pakfire_build_setup(Pakfire pakfire) {
+int pakfire_build_setup(struct pakfire* pakfire) {
char path[PATH_MAX];
int r;
return 0;
}
-static int pakfire_build_run_script(Pakfire pakfire, const char* filename, const char* args[],
+static int pakfire_build_run_script(struct pakfire* pakfire, const char* filename, const char* args[],
pakfire_execute_logging_callback logging_callback, void* data) {
char* script = NULL;
size_t size = 0;
return 0;
}
-static int pakfire_build_find_dependencies(Pakfire pakfire,
+static int pakfire_build_find_dependencies(struct pakfire* pakfire,
struct pakfire_package* pkg, struct pakfire_filelist* filelist, const char* buildroot) {
char** provides = NULL;
char** requires = NULL;
return 0;
}
-static int pakfire_build_package_add_files(Pakfire pakfire, struct pakfire_parser* makefile,
+static int pakfire_build_package_add_files(struct pakfire* pakfire, struct pakfire_parser* makefile,
const char* buildroot, const char* namespace, struct pakfire_package* pkg,
struct pakfire_packager* packager) {
struct pakfire_filelist* filelist = NULL;
return r;
}
-static int pakfire_build_add_scriptlet_requires(Pakfire pakfire, struct pakfire_package* pkg,
+static int pakfire_build_add_scriptlet_requires(struct pakfire* pakfire, struct pakfire_package* pkg,
struct pakfire_scriptlet* scriptlet) {
char** prerequires = NULL;
char path[PATH_MAX];
return r;
}
-static int pakfire_build_package_add_scriptlet(Pakfire pakfire, struct pakfire_package* pkg,
+static int pakfire_build_package_add_scriptlet(struct pakfire* pakfire, struct pakfire_package* pkg,
struct pakfire_packager* packager, const char* type, const char* data) {
struct pakfire_scriptlet* scriptlet = NULL;
char* shell = NULL;
return r;
}
-static int pakfire_build_package_add_scriptlets(Pakfire pakfire, struct pakfire_parser* makefile,
+static int pakfire_build_package_add_scriptlets(struct pakfire* pakfire, struct pakfire_parser* makefile,
const char* namespace, struct pakfire_package* pkg, struct pakfire_packager* packager) {
char name[NAME_MAX];
int r;
return 0;
}
-static int pakfire_build_package(Pakfire pakfire, struct pakfire_parser* makefile,
+static int pakfire_build_package(struct pakfire* pakfire, struct pakfire_parser* makefile,
uuid_t* build_id, const char* buildroot, const char* namespace, const char* target) {
struct pakfire_repo* repo = NULL;
struct pakfire_package* pkg = NULL;
return r;
}
-static int pakfire_build_packages(Pakfire pakfire, struct pakfire_parser* makefile,
+static int pakfire_build_packages(struct pakfire* pakfire, struct pakfire_parser* makefile,
uuid_t* build_id, const char* buildroot, const char* target) {
DEBUG(pakfire, "Creating packages...");
int r = 1;
return r;
}
-static int pakfire_build_stage(Pakfire pakfire, struct pakfire_parser* makefile, const char* stage,
+static int pakfire_build_stage(struct pakfire* pakfire, struct pakfire_parser* makefile, const char* stage,
pakfire_execute_logging_callback logging_callback, void* data) {
char template[1024];
NULL,
};
-static int pakfire_build_run_post_build_scripts(Pakfire pakfire, const char* buildroot,
+static int pakfire_build_run_post_build_scripts(struct pakfire* pakfire, const char* buildroot,
pakfire_execute_logging_callback logging_callback, void* data) {
// Set default arguments for build scripts
const char* args[] = {
return 0;
}
-static int pakfire_build_makefile(Pakfire pakfire, const char* path, const char* target,
+static int pakfire_build_makefile(struct pakfire* pakfire, const char* path, const char* target,
uuid_t* build_id, int flags,
pakfire_execute_logging_callback logging_callback, void* data) {
struct pakfire_parser* makefile = NULL;
return r;
}
-PAKFIRE_EXPORT int pakfire_build(Pakfire pakfire, const char* path,
+PAKFIRE_EXPORT int pakfire_build(struct pakfire* pakfire, const char* path,
const char* target, const char* id, int flags,
pakfire_execute_logging_callback logging_callback, void* data) {
char makefiles[PATH_MAX];
return r;
}
-PAKFIRE_EXPORT int pakfire_shell(Pakfire pakfire) {
+PAKFIRE_EXPORT int pakfire_shell(struct pakfire* pakfire) {
const char* argv[] = {
"/bin/bash", "--login", NULL,
};
#include <pakfire/cgroup.h>
#include <pakfire/logging.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
/*
return parent;
}
-static int pakfire_cgroup_supported(Pakfire pakfire) {
+static int pakfire_cgroup_supported(struct pakfire* pakfire) {
if (pakfire_cgroups_supported < 0) {
struct statfs fs;
return pakfire_cgroups_supported;
}
-static int pakfire_cgroup_make_path(Pakfire pakfire, char* path, size_t length,
+static int pakfire_cgroup_make_path(struct pakfire* pakfire, char* path, size_t length,
const char* subgroup, const char* file) {
// Store up to where we have written and how much space is left
char* p = path;
return length - l;
}
-static FILE* pakfire_cgroup_fopen(Pakfire pakfire,
+static FILE* pakfire_cgroup_fopen(struct pakfire* pakfire,
const char* group, const char* file, const char* mode) {
char path[PATH_MAX];
return f;
}
-static int pakfire_cgroup_fprintf(Pakfire pakfire,
+static int pakfire_cgroup_fprintf(struct pakfire* pakfire,
const char* group, const char* file, const char* format, ...) {
char buffer[64];
ssize_t length;
return r;
}
-static int pakfire_cgroup_enable_controller(Pakfire pakfire,
+static int pakfire_cgroup_enable_controller(struct pakfire* pakfire,
const char* group, const char* controller) {
// Enable controller
int r = pakfire_cgroup_fprintf(pakfire, group, "cgroup.subtree_control",
return 0;
}
-static int pakfire_cgroup_enable_controllers(Pakfire pakfire,
+static int pakfire_cgroup_enable_controllers(struct pakfire* pakfire,
const char* group, const char** controllers) {
int r;
return 0;
}
-int pakfire_cgroup_create(Pakfire pakfire, const char* group) {
+int pakfire_cgroup_create(struct pakfire* pakfire, const char* group) {
int supported = pakfire_cgroup_supported(pakfire);
if (!supported) {
errno = ENOTSUP;
return 0;
}
-int pakfire_cgroup_destroy(Pakfire pakfire, const char* group) {
+int pakfire_cgroup_destroy(struct pakfire* pakfire, const char* group) {
// Never attempt to destroy root
if (!*group)
return EINVAL;
return 0;
}
-DIR* pakfire_cgroup_opendir(Pakfire pakfire, const char* group) {
+DIR* pakfire_cgroup_opendir(struct pakfire* pakfire, const char* group) {
// Make path
char path[PATH_MAX];
int r = pakfire_cgroup_make_path(pakfire, path, sizeof(path) - 1, group, NULL);
return opendir(path);
}
-int pakfire_cgroup_attach(Pakfire pakfire, const char* group, pid_t pid) {
+int pakfire_cgroup_attach(struct pakfire* pakfire, const char* group, pid_t pid) {
int r = pakfire_cgroup_fprintf(pakfire, group, "cgroup.procs", "%d", pid);
if (r < 0) {
ERROR(pakfire, "Could not attach process %d to cgroup %s: %m\n", pid, group);
return 0;
}
-int pakfire_cgroup_detach(Pakfire pakfire, const char* group, pid_t pid) {
+int pakfire_cgroup_detach(struct pakfire* pakfire, const char* group, pid_t pid) {
char* parent = pakfire_cgroup_parent_name(group);
if (!parent)
return EINVAL;
return 1;
}
-static ssize_t pakfire_cgroup_procs_callback(Pakfire pakfire, const char* group,
- int (*func)(Pakfire pakfire, pid_t pid, void* data), void* data) {
+static ssize_t pakfire_cgroup_procs_callback(struct pakfire* pakfire, const char* group,
+ int (*func)(struct pakfire* pakfire, pid_t pid, void* data), void* data) {
FILE* f = pakfire_cgroup_fopen(pakfire, group, "cgroup.procs", "r");
if (!f)
return -1;
return num_processes;
}
-ssize_t pakfire_cgroup_num_processes(Pakfire pakfire, const char* group) {
+ssize_t pakfire_cgroup_num_processes(struct pakfire* pakfire, const char* group) {
return pakfire_cgroup_procs_callback(pakfire, group, NULL, NULL);
}
-static int send_signal(Pakfire pakfire, pid_t pid, void* data) {
+static int send_signal(struct pakfire* pakfire, pid_t pid, void* data) {
int* signum = (int*)data;
DEBUG(pakfire, "Sending signal %d to PID %d\n", *signum, pid);
return 0;
}
-int pakfire_cgroup_killall(Pakfire pakfire, const char* group) {
+int pakfire_cgroup_killall(struct pakfire* pakfire, const char* group) {
DEBUG(pakfire, "Killing all processes in cgroup %s\n", group);
int signum = SIGTERM;
return 1;
}
-int pakfire_cgroup_cpustat(Pakfire pakfire, const char* group,
+int pakfire_cgroup_cpustat(struct pakfire* pakfire, const char* group,
struct pakfire_cgroup_cpustat* st) {
FILE* f = pakfire_cgroup_fopen(pakfire, group, "cpu.stat", "r");
if (!f)
return 0;
}
-int pakfire_cgroup_set_nice(Pakfire pakfire, const char* group, int level) {
+int pakfire_cgroup_set_nice(struct pakfire* pakfire, const char* group, int level) {
DEBUG(pakfire, "Setting nice level of cgroup %s to %d\n", group, level);
int r = pakfire_cgroup_fprintf(pakfire, group, "cpu.weight.nice", "%d", level);
#include <pakfire/package.h>
#include <pakfire/pakfire.h>
#include <pakfire/repo.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
#define DATABASE_PATH PAKFIRE_PRIVATE_DIR "/packages.db"
#define SCHEMA_MIN_SUP 7
struct pakfire_db {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
char path[PATH_MAX];
};
static void logging_callback(void* data, int r, const char* msg) {
- Pakfire pakfire = (Pakfire)data;
+ struct pakfire* pakfire = (struct pakfire*)data;
ERROR(pakfire, "Database Error: %s: %s\n",
sqlite3_errstr(r), msg);
return 0;
}
-int pakfire_db_open(struct pakfire_db** db, Pakfire pakfire, int flags) {
+int pakfire_db_open(struct pakfire_db** db, struct pakfire* pakfire, int flags) {
int r = 1;
struct pakfire_db* o = calloc(1, sizeof(*o));
return packages;
}
-static void pakfire_db_add_userinstalled(Pakfire pakfire, const char* name) {
+static void pakfire_db_add_userinstalled(struct pakfire* pakfire, const char* name) {
Pool* pool = pakfire_get_solv_pool(pakfire);
// Convert name to ID
#include <pakfire/parser.h>
#include <pakfire/private.h>
#include <pakfire/repo.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
// XXX for now
#define PAKFIRE_MACROS_DIR "/usr/lib/pakfire/macros"
#define PAKFIRE_MACROS_GLOB_PATTERN PAKFIRE_MACROS_DIR "/*.macro"
-static int pakfire_makefile_set_defaults(Pakfire pakfire,
+static int pakfire_makefile_set_defaults(struct pakfire* pakfire,
struct pakfire_parser* parser, const char* path) {
char buffer[1024];
int r;
return 0;
}
-int pakfire_read_makefile(struct pakfire_parser** parser, Pakfire pakfire,
+int pakfire_read_makefile(struct pakfire_parser** parser, struct pakfire* pakfire,
const char* path, struct pakfire_parser_error** error) {
int r = 1;
}
static int pakfire_dist_create_downloader_and_mirrorlist(
- Pakfire pakfire, struct pakfire_parser* makefile,
+ struct pakfire* pakfire, struct pakfire_parser* makefile,
struct pakfire_downloader** downloader, struct pakfire_mirrorlist** mirrorlist) {
// Create the downloader
int r = pakfire_downloader_create(downloader, pakfire);
return r;
}
-static int pakfire_dist_add_source(Pakfire pakfire, struct pakfire_packager* packager,
+static int pakfire_dist_add_source(struct pakfire* pakfire, struct pakfire_packager* packager,
struct pakfire_package* pkg, struct pakfire_downloader* downloader,
struct pakfire_mirrorlist* mirrorlist, const char* filename) {
int r;
return pakfire_packager_add(packager, cache_path, archive_path);
}
-static int pakfire_dist_add_sources(Pakfire pakfire, struct pakfire_packager* packager,
+static int pakfire_dist_add_sources(struct pakfire* pakfire, struct pakfire_packager* packager,
struct pakfire_package* pkg, struct pakfire_parser* makefile) {
// Fetch sources
char** sources = pakfire_parser_get_split(makefile, NULL, "sources", ' ');
return r;
}
-static int pakfire_dist_add_files(Pakfire pakfire, struct pakfire_packager* packager,
+static int pakfire_dist_add_files(struct pakfire* pakfire, struct pakfire_packager* packager,
const char* path) {
int r = 1;
return r;
}
-PAKFIRE_EXPORT int pakfire_dist(Pakfire pakfire, const char* path, const char* target) {
+PAKFIRE_EXPORT int pakfire_dist(struct pakfire* pakfire, const char* path, const char* target) {
struct pakfire_parser* makefile;
struct pakfire_parser_error* error = NULL;
#include <pakfire/logging.h>
#include <pakfire/pakfire.h>
#include <pakfire/progressbar.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
// Retry a mirror up to N times before marking it as broken
};
struct pakfire_downloader {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
struct pakfire_progressbar* progressbar;
free(downloader);
}
-int pakfire_downloader_create(struct pakfire_downloader** downloader, Pakfire pakfire) {
+int pakfire_downloader_create(struct pakfire_downloader** downloader, struct pakfire* pakfire) {
// Fail if pakfire is running in offline mode
if (pakfire_has_flag(pakfire, PAKFIRE_FLAGS_OFFLINE)) {
ERROR(pakfire, "Cannot initialize downloader in offline mode\n");
#ifdef ENABLE_DEBUG
static int debug_callback(CURL *handle, curl_infotype type,
char* data, size_t size, void* private) {
- Pakfire pakfire = (Pakfire)private;
+ struct pakfire* pakfire = (struct pakfire*)private;
switch (type) {
case CURLINFO_TEXT:
}
struct pakfire_mirrorlist {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
STAILQ_HEAD(mirrors, pakfire_mirror) mirrors;
free(ml);
}
-int pakfire_mirrorlist_create(struct pakfire_mirrorlist** mirrorlist, Pakfire pakfire) {
+int pakfire_mirrorlist_create(struct pakfire_mirrorlist** mirrorlist, struct pakfire* pakfire) {
struct pakfire_mirrorlist* ml = calloc(1, sizeof(*ml));
if (!ml)
return ENOMEM;
#include <pakfire/execute.h>
#include <pakfire/logging.h>
#include <pakfire/private.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
#define ENVIRON_SIZE 128
};
struct pakfire_execute {
- Pakfire pakfire;
+ struct pakfire* pakfire;
const char** argv;
char* envp[ENVIRON_SIZE];
If it finds a whole line in it, it will send it to the logger and repeat the process.
If not newline character is found, it will try to read more data until it finds one.
*/
-static int pakfire_execute_logger_proxy(Pakfire pakfire, int fd,
+static int pakfire_execute_logger_proxy(struct pakfire* pakfire, int fd,
pakfire_execute_logging_callback logging_callback, void* data, int priority,
struct pakfire_execute_buffer* buffer) {
char line[BUFFER_SIZE + 1];
return 0;
}
-static int pakfire_execute_logger(Pakfire pakfire, pakfire_execute_logging_callback logging_callback,
+static int pakfire_execute_logger(struct pakfire* pakfire, pakfire_execute_logging_callback logging_callback,
void* data, pid_t pid, int stdout, int stderr, int* status) {
int epollfd = -1;
struct epoll_event ev;
return r;
}
-static int default_logging_callback(Pakfire pakfire, void* data, int priority,
+static int default_logging_callback(struct pakfire* pakfire, void* data, int priority,
const char* line, size_t length) {
switch (priority) {
case LOG_INFO:
return 0;
}
-int pakfire_execute_capture_stdout(Pakfire pakfire, void* data, int priority,
+int pakfire_execute_capture_stdout(struct pakfire* pakfire, void* data, int priority,
const char* line, size_t length) {
char** output = (char**)data;
return default_logging_callback(pakfire, NULL, priority, line, length);
}
-int pakfire_execute_capture_stdout_to_array(Pakfire pakfire, void* data, int priority,
+int pakfire_execute_capture_stdout_to_array(struct pakfire* pakfire, void* data, int priority,
const char* line, size_t length) {
char*** array = (char***)data;
static int pakfire_execute_fork(void* data) {
struct pakfire_execute* env = (struct pakfire_execute*)data;
- Pakfire pakfire = env->pakfire;
+ struct pakfire* pakfire = env->pakfire;
const char* root = pakfire_get_path(pakfire);
const char* arch = pakfire_get_arch(pakfire);
return r;
}
-PAKFIRE_EXPORT int pakfire_execute(Pakfire pakfire, const char* argv[], char* envp[],
+PAKFIRE_EXPORT int pakfire_execute(struct pakfire* pakfire, const char* argv[], char* envp[],
int flags, pakfire_execute_logging_callback logging_callback, void* data) {
DIR* cgroupdir = NULL;
int r;
return r;
}
-PAKFIRE_EXPORT int pakfire_execute_command(Pakfire pakfire, const char* command, char* envp[],
+PAKFIRE_EXPORT int pakfire_execute_command(struct pakfire* pakfire, const char* command, char* envp[],
int flags, pakfire_execute_logging_callback logging_callback, void* data) {
const char* argv[2] = {
command, NULL,
return pakfire_execute(pakfire, argv, envp, flags, logging_callback, data);
}
-PAKFIRE_EXPORT int pakfire_execute_script(Pakfire pakfire, const char* script, const size_t size,
+PAKFIRE_EXPORT int pakfire_execute_script(struct pakfire* pakfire, const char* script, const size_t size,
const char* args[], char* envp[], int flags, pakfire_execute_logging_callback logging_callback, void* data) {
const char* root = pakfire_get_path(pakfire);
const char** argv = NULL;
return r;
}
-int pakfire_execute_ldconfig(Pakfire pakfire) {
+int pakfire_execute_ldconfig(struct pakfire* pakfire) {
char path[PATH_MAX];
// Check if ldconfig exists before calling it to avoid overhead
#include <pakfire/util.h>
struct pakfire_file {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
char path[PATH_MAX];
//int is_datafile;
};
-PAKFIRE_EXPORT int pakfire_file_create(struct pakfire_file** file, Pakfire pakfire) {
+PAKFIRE_EXPORT int pakfire_file_create(struct pakfire_file** file, struct pakfire* pakfire) {
struct pakfire_file* f = calloc(1, sizeof(*f));
if (!f)
return -ENOMEM;
return 0;
}
-int pakfire_file_create_from_archive_entry(struct pakfire_file** file, Pakfire pakfire,
+int pakfire_file_create_from_archive_entry(struct pakfire_file** file, struct pakfire* pakfire,
struct archive_entry* entry) {
int r = pakfire_file_create(file, pakfire);
if (r)
#include <pakfire/util.h>
struct pakfire_filelist {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
struct pakfire_file** elements;
return 0;
}
-PAKFIRE_EXPORT int pakfire_filelist_create(struct pakfire_filelist** list, Pakfire pakfire) {
+PAKFIRE_EXPORT int pakfire_filelist_create(struct pakfire_filelist** list, struct pakfire* pakfire) {
struct pakfire_filelist* l = calloc(1, sizeof(*l));
if (!l)
return -ENOMEM;
qsort(list->elements, list->size, sizeof(*list->elements), __sort);
}
-static int pakfire_filelist_parse_line(struct pakfire_file** file, Pakfire pakfire,
+static int pakfire_filelist_parse_line(struct pakfire_file** file, struct pakfire* pakfire,
char* line, unsigned int format) {
unsigned int i = 0;
return 0;
}
-int pakfire_filelist_create_from_file(struct pakfire_filelist** list, Pakfire pakfire,
+int pakfire_filelist_create_from_file(struct pakfire_filelist** list, struct pakfire* pakfire,
char* data, unsigned int format) {
int r = pakfire_filelist_create(list, pakfire);
if (r)
#include <pakfire/package.h>
#include <pakfire/repo.h>
#include <pakfire/scriptlet.h>
-#include <pakfire/types.h>
typedef enum pakfire_archive_verify_status {
PAKFIRE_ARCHIVE_VERIFY_UNKNOWN = 0,
PAKFIRE_ARCHIVE_VERIFY_ERROR,
} pakfire_archive_verify_status_t;
-int pakfire_archive_open(struct pakfire_archive** archive, Pakfire pakfire, const char* path);
+int pakfire_archive_open(struct pakfire_archive** archive, struct pakfire* pakfire, const char* path);
struct pakfire_archive* pakfire_archive_ref(struct pakfire_archive* archive);
struct pakfire_archive* pakfire_archive_unref(struct pakfire_archive* archive);
-Pakfire pakfire_archive_get_pakfire(struct pakfire_archive* archive);
+struct pakfire* pakfire_archive_get_pakfire(struct pakfire_archive* archive);
char* pakfire_archive_get(struct pakfire_archive* archive, const char* namespace, const char* key);
#define PAKFIRE_BUILD_H
#include <pakfire/execute.h>
-#include <pakfire/types.h>
enum pakfire_build_flags {
PAKFIRE_BUILD_INTERACTIVE = (1 << 0),
};
-int pakfire_build_setup(Pakfire pakfire);
+int pakfire_build_setup(struct pakfire* pakfire);
-int pakfire_build(Pakfire pakfire, const char* path, const char* target,
+int pakfire_build(struct pakfire* pakfire, const char* path, const char* target,
const char* id, int flags, pakfire_execute_logging_callback logging_callback, void* data);
-int pakfire_shell(Pakfire pakfire);
+int pakfire_shell(struct pakfire* pakfire);
#endif /* PAKFIRE_BUILD_H */
#include <sys/types.h>
#include <time.h>
-#include <pakfire/types.h>
+#include <pakfire/pakfire.h>
int pakfire_cgroup_random_name(char* template);
-int pakfire_cgroup_create(Pakfire pakfire, const char* group);
-int pakfire_cgroup_destroy(Pakfire pakfire, const char* group);
+int pakfire_cgroup_create(struct pakfire* pakfire, const char* group);
+int pakfire_cgroup_destroy(struct pakfire* pakfire, const char* group);
-DIR* pakfire_cgroup_opendir(Pakfire pakfire, const char* group);
+DIR* pakfire_cgroup_opendir(struct pakfire* pakfire, const char* group);
-int pakfire_cgroup_attach(Pakfire pakfire, const char* group, pid_t pid);
-int pakfire_cgroup_detach(Pakfire pakfire, const char* group, pid_t pid);
+int pakfire_cgroup_attach(struct pakfire* pakfire, const char* group, pid_t pid);
+int pakfire_cgroup_detach(struct pakfire* pakfire, const char* group, pid_t pid);
-ssize_t pakfire_cgroup_num_processes(Pakfire pakfire, const char* group);
+ssize_t pakfire_cgroup_num_processes(struct pakfire* pakfire, const char* group);
-int pakfire_cgroup_killall(Pakfire pakfire, const char* group);
+int pakfire_cgroup_killall(struct pakfire* pakfire, const char* group);
struct pakfire_cgroup_cpustat {
struct timeval usage;
struct timeval system;
};
-int pakfire_cgroup_cpustat(Pakfire pakfire, const char* group,
+int pakfire_cgroup_cpustat(struct pakfire* pakfire, const char* group,
struct pakfire_cgroup_cpustat* st);
-int pakfire_cgroup_set_nice(Pakfire pakfire, const char* group, int level);
+int pakfire_cgroup_set_nice(struct pakfire* pakfire, const char* group, int level);
#endif
#include <pakfire/archive.h>
#include <pakfire/package.h>
+#include <pakfire/pakfire.h>
#include <pakfire/repo.h>
#include <pakfire/scriptlet.h>
-#include <pakfire/types.h>
struct pakfire_db;
PAKFIRE_DB_READWRITE = (1 << 0),
};
-int pakfire_db_open(struct pakfire_db** db, Pakfire pakfire, int flags);
+int pakfire_db_open(struct pakfire_db** db, struct pakfire* pakfire, int flags);
struct pakfire_db* pakfire_db_ref(struct pakfire_db* db);
struct pakfire_db* pakfire_db_unref(struct pakfire_db* db);
#ifndef PAKFIRE_DIST_H
#define PAKFIRE_DIST_H
-#include <pakfire/types.h>
+#include <pakfire/pakfire.h>
-int pakfire_dist(Pakfire pakfire, const char* path, const char* target);
+int pakfire_dist(struct pakfire* pakfire, const char* path, const char* target);
#ifdef PAKFIRE_PRIVATE
#include <pakfire/parser.h>
-int pakfire_read_makefile(struct pakfire_parser** parser, Pakfire pakfire,
+int pakfire_read_makefile(struct pakfire_parser** parser, struct pakfire* pakfire,
const char* path, struct pakfire_parser_error** error);
#endif
#ifdef PAKFIRE_PRIVATE
-#include <pakfire/types.h>
-
struct pakfire_downloader;
struct pakfire_mirrorlist;
+#include <pakfire/pakfire.h>
+
enum pakfire_transfer_flags {
PAKFIRE_TRANSFER_NONE = 0,
PAKFIRE_TRANSFER_NOPROGRESS = (1 << 0),
PAKFIRE_TRANSFER_NOTEMP = (1 << 1),
};
-int pakfire_downloader_create(struct pakfire_downloader** downloader, Pakfire pakfire);
+int pakfire_downloader_create(struct pakfire_downloader** downloader, struct pakfire* pakfire);
struct pakfire_downloader* pakfire_downloader_ref(struct pakfire_downloader* downloader);
struct pakfire_downloader* pakfire_downloader_unref(struct pakfire_downloader* downloader);
// Mirror lists
-int pakfire_mirrorlist_create(struct pakfire_mirrorlist** ml, Pakfire pakfire);
+int pakfire_mirrorlist_create(struct pakfire_mirrorlist** ml, struct pakfire* pakfire);
struct pakfire_mirrorlist* pakfire_mirrorlist_ref(struct pakfire_mirrorlist* ml);
struct pakfire_mirrorlist* pakfire_mirrorlist_unref(struct pakfire_mirrorlist* ml);
#ifndef PAKFIRE_EXECUTE_H
#define PAKFIRE_EXECUTE_H
-#include <pakfire/types.h>
+#include <pakfire/pakfire.h>
-typedef int (*pakfire_execute_logging_callback)(Pakfire pakfire, void* data,
+typedef int (*pakfire_execute_logging_callback)(struct pakfire* pakfire, void* data,
int priority, const char* line, size_t length);
-int pakfire_execute(Pakfire pakfire, const char* argv[], char* envp[],
+int pakfire_execute(struct pakfire* pakfire, const char* argv[], char* envp[],
int flags, pakfire_execute_logging_callback logging_callback, void* data);
-int pakfire_execute_command(Pakfire pakfire, const char* command, char* envp[],
+int pakfire_execute_command(struct pakfire* pakfire, const char* command, char* envp[],
int flags, pakfire_execute_logging_callback logging_callback, void* data);
-int pakfire_execute_script(Pakfire pakfire, const char* script, const size_t size,
+int pakfire_execute_script(struct pakfire* pakfire, const char* script, const size_t size,
const char* args[], char* envp[], int flags, pakfire_execute_logging_callback logging_callback, void* data);
enum {
#ifdef PAKFIRE_PRIVATE
-int pakfire_execute_capture_stdout(Pakfire pakfire, void* data, int priority,
+int pakfire_execute_capture_stdout(struct pakfire* pakfire, void* data, int priority,
const char* line, size_t length);
-int pakfire_execute_capture_stdout_to_array(Pakfire pakfire, void* data, int priority,
+int pakfire_execute_capture_stdout_to_array(struct pakfire* pakfire, void* data, int priority,
const char* line, size_t length);
-int pakfire_execute_ldconfig(Pakfire pakfire);
+int pakfire_execute_ldconfig(struct pakfire* pakfire);
#endif
#include <time.h>
#include <unistd.h>
-#include <pakfire/types.h>
-
struct pakfire_file;
-int pakfire_file_create(struct pakfire_file** file, Pakfire pakfire);
+#include <pakfire/pakfire.h>
+
+int pakfire_file_create(struct pakfire_file** file, struct pakfire* pakfire);
struct pakfire_file* pakfire_file_ref(struct pakfire_file* file);
struct pakfire_file* pakfire_file_unref(struct pakfire_file* file);
#include <archive_entry.h>
-int pakfire_file_create_from_archive_entry(struct pakfire_file** file, Pakfire pakfire,
+int pakfire_file_create_from_archive_entry(struct pakfire_file** file, struct pakfire* pakfire,
struct archive_entry* entry);
struct archive_entry* pakfire_file_archive_entry(struct pakfire_file* file);
int pakfire_file_copy_archive_entry(struct pakfire_file* file, struct archive_entry* entry);
struct pakfire_filelist;
#include <pakfire/file.h>
-#include <pakfire/types.h>
-int pakfire_filelist_create(struct pakfire_filelist** list, Pakfire pakfire);
+int pakfire_filelist_create(struct pakfire_filelist** list, struct pakfire* pakfire);
struct pakfire_filelist* pakfire_filelist_ref(struct pakfire_filelist* list);
struct pakfire_filelist* pakfire_filelist_unref(struct pakfire_filelist* list);
#include <stdio.h>
-int pakfire_filelist_create_from_file(struct pakfire_filelist** list, Pakfire pakfire,
+int pakfire_filelist_create_from_file(struct pakfire_filelist** list, struct pakfire* pakfire,
char* data, unsigned int format);
int pakfire_filelist_scan(struct pakfire_filelist* list, const char* root,
struct pakfire_key;
-#include <pakfire/types.h>
+#include <pakfire/pakfire.h>
typedef enum pakfire_key_export_mode {
PAKFIRE_KEY_EXPORT_MODE_PUBLIC = 0,
struct pakfire_key* pakfire_key_ref(struct pakfire_key* key);
void pakfire_key_unref(struct pakfire_key* key);
-int pakfire_key_fetch(struct pakfire_key** key, Pakfire pakfire,
+int pakfire_key_fetch(struct pakfire_key** key, struct pakfire* pakfire,
const char* uid, const char* fingerprint);
-struct pakfire_key* pakfire_key_get(Pakfire pakfire, const char* fingerprint);
+struct pakfire_key* pakfire_key_get(struct pakfire* pakfire, const char* fingerprint);
int pakfire_key_delete(struct pakfire_key* key);
// Access key properties
time_t pakfire_key_get_expires(struct pakfire_key* key);
int pakfire_key_is_revoked(struct pakfire_key* key);
-int pakfire_key_generate(struct pakfire_key** key, Pakfire pakfire,
+int pakfire_key_generate(struct pakfire_key** key, struct pakfire* pakfire,
const char* algo, const char* userid);
int pakfire_key_export(struct pakfire_key* key, FILE* f, pakfire_key_export_mode_t mode);
-int pakfire_key_import(Pakfire pakfire, FILE* f, struct pakfire_key*** keys);
+int pakfire_key_import(struct pakfire* pakfire, FILE* f, struct pakfire_key*** keys);
char* pakfire_key_dump(struct pakfire_key* key);
#include <gpgme.h>
-int pakfire_key_create(struct pakfire_key** key, Pakfire pakfire, gpgme_key_t gpgkey);
+int pakfire_key_create(struct pakfire_key** key, struct pakfire* pakfire, gpgme_key_t gpgkey);
#endif
#include <syslog.h>
#include <pakfire/pakfire.h>
-#include <pakfire/types.h>
void pakfire_log_stderr(void* data, int priority, const char* file,
int line, const char* fn, const char* format, va_list args);
// This function does absolutely nothing
static inline void __attribute__((always_inline, format(printf, 2, 3)))
- pakfire_log_null(Pakfire pakfire, const char *format, ...) {}
+ pakfire_log_null(struct pakfire* pakfire, const char *format, ...) {}
#define pakfire_log_condition(pakfire, prio, arg...) \
do { \
#include <pakfire/filelist.h>
#include <pakfire/packagelist.h>
+#include <pakfire/pakfire.h>
#include <pakfire/repo.h>
-#include <pakfire/types.h>
struct pakfire_package;
-struct pakfire_package* pakfire_package_create(Pakfire pakfire, struct pakfire_repo* repo,
+struct pakfire_package* pakfire_package_create(struct pakfire* pakfire, struct pakfire_repo* repo,
const char* name, const char* evr, const char* arch);
struct pakfire_package* pakfire_package_ref(struct pakfire_package* pkg);
struct pakfire_package* pakfire_package_unref(struct pakfire_package* pkg);
-Pakfire pakfire_package_get_pakfire(struct pakfire_package* pkg);
+struct pakfire* pakfire_package_get_pakfire(struct pakfire_package* pkg);
int pakfire_package_eq(struct pakfire_package* pkg1, struct pakfire_package* pkg2);
int pakfire_package_cmp(struct pakfire_package* pkg1, struct pakfire_package* pkg2);
#ifdef PAKFIRE_PRIVATE
+#include <stdint.h>
+
#include <solv/pooltypes.h>
#include <uuid/uuid.h>
-struct pakfire_package* pakfire_package_create_from_solvable(Pakfire pakfire, Id id);
+struct pakfire_package* pakfire_package_create_from_solvable(struct pakfire* pakfire, Id id);
void pakfire_package_set_build_id_from_uuid(struct pakfire_package* pkg, uuid_t* build_id);
uint64_t pakfire_package_get_dbid(struct pakfire_package* pkg);
#ifndef PAKFIRE_PACKAGELIST_H
#define PAKFIRE_PACKAGELIST_H
-#include <pakfire/package.h>
-#include <pakfire/types.h>
-
struct pakfire_packagelist;
-int pakfire_packagelist_create(struct pakfire_packagelist** list, Pakfire pakfire);
+#include <pakfire/package.h>
+#include <pakfire/pakfire.h>
+
+int pakfire_packagelist_create(struct pakfire_packagelist** list, struct pakfire* pakfire);
struct pakfire_packagelist* pakfire_packagelist_ref(struct pakfire_packagelist* list);
struct pakfire_packagelist* pakfire_packagelist_unref(struct pakfire_packagelist* list);
#include <solv/queue.h>
-int pakfire_packagelist_create_from_queue(struct pakfire_packagelist** list, Pakfire pakfire, Queue* q);
+int pakfire_packagelist_create_from_queue(struct pakfire_packagelist** list, struct pakfire* pakfire, Queue* q);
#endif
#include <pakfire/package.h>
#include <pakfire/scriptlet.h>
-#include <pakfire/types.h>
struct pakfire_packager;
#include <sys/stat.h>
#include <time.h>
+struct pakfire;
+
#include <pakfire/key.h>
+#include <pakfire/packagelist.h>
#include <pakfire/parser.h>
#include <pakfire/repo.h>
#include <pakfire/repolist.h>
-#include <pakfire/types.h>
enum pakfire_flags {
PAKFIRE_FLAGS_OFFLINE = (1 << 0),
typedef void (*pakfire_log_function_t)(void* data, int priority, const char* file,
int line, const char* fn, const char* format, va_list args);
-int pakfire_create(Pakfire* pakfire, const char* path, const char* arch,
+int pakfire_create(struct pakfire** pakfire, const char* path, const char* arch,
const char* conf, int flags, pakfire_log_function_t log, void* data);
-Pakfire pakfire_ref(Pakfire pakfire);
-Pakfire pakfire_unref(Pakfire pakfire);
+struct pakfire* pakfire_ref(struct pakfire* pakfire);
+struct pakfire* pakfire_unref(struct pakfire* pakfire);
-const char* pakfire_get_path(Pakfire pakfire);
+const char* pakfire_get_path(struct pakfire* pakfire);
-int pakfire_clean(Pakfire pakfire, int flags);
-int pakfire_refresh(Pakfire pakfire, int flags);
+int pakfire_clean(struct pakfire* pakfire, int flags);
+int pakfire_refresh(struct pakfire* pakfire, int flags);
-int pakfire_bind(Pakfire pakfire, const char* src, const char* dst, int flags);
+int pakfire_bind(struct pakfire* pakfire, const char* src, const char* dst, int flags);
-int pakfire_list_keys(Pakfire pakfire, struct pakfire_key*** keys);
+int pakfire_list_keys(struct pakfire* pakfire, struct pakfire_key*** keys);
-int pakfire_copy_in(Pakfire pakfire, const char* src, const char* dst);
-int pakfire_copy_out(Pakfire pakfire, const char* src, const char* dst);
+int pakfire_copy_in(struct pakfire* pakfire, const char* src, const char* dst);
+int pakfire_copy_out(struct pakfire* pakfire, const char* src, const char* dst);
-const char* pakfire_get_arch(Pakfire pakfire);
+const char* pakfire_get_arch(struct pakfire* pakfire);
-int pakfire_version_compare(Pakfire pakfire, const char* evr1, const char* evr2);
+int pakfire_version_compare(struct pakfire* pakfire, const char* evr1, const char* evr2);
-struct pakfire_repolist* pakfire_get_repos(Pakfire pakfire);
-struct pakfire_repo* pakfire_get_repo(Pakfire pakfire, const char* name);
+struct pakfire_repolist* pakfire_get_repos(struct pakfire* pakfire);
+struct pakfire_repo* pakfire_get_repo(struct pakfire* pakfire, const char* name);
-int pakfire_whatprovides(Pakfire pakfire, const char* what, int flags,
+int pakfire_whatprovides(struct pakfire* pakfire, const char* what, int flags,
struct pakfire_packagelist** list);
-int pakfire_whatrequires(Pakfire pakfire, const char* what, int flags,
+int pakfire_whatrequires(struct pakfire* pakfire, const char* what, int flags,
struct pakfire_packagelist** list);
// Search
PAKFIRE_SEARCH_NAME_ONLY = (1 << 0),
};
-int pakfire_search(Pakfire pakfire, const char* what, int flags,
+int pakfire_search(struct pakfire* pakfire, const char* what, int flags,
struct pakfire_packagelist** list);
// Logging
-int pakfire_log_get_priority(Pakfire pakfire);
-void pakfire_log_set_priority(Pakfire pakfire, int priority);
+int pakfire_log_get_priority(struct pakfire* pakfire);
+void pakfire_log_set_priority(struct pakfire* pakfire, int priority);
// Install/Erase/Update
-int pakfire_install(Pakfire pakfire, int solver_flags, const char** packages,
+int pakfire_install(struct pakfire* pakfire, int solver_flags, const char** packages,
const char** locks, int job_flags, int* changed);
-int pakfire_erase(Pakfire pakfire, int solver_flags, const char** packages,
+int pakfire_erase(struct pakfire* pakfire, int solver_flags, const char** packages,
const char** locks, int job_flags, int* changed);
-int pakfire_update(Pakfire pakfire, int solver_flags, const char** packages,
+int pakfire_update(struct pakfire* pakfire, int solver_flags, const char** packages,
const char** locks, int jobs_flags, int* changed);
// Check
-int pakfire_check(Pakfire pakfire);
+int pakfire_check(struct pakfire* pakfire);
// Sync
-int pakfire_sync(Pakfire pakfire, int solver_flags, int flags, int* changed);
+int pakfire_sync(struct pakfire* pakfire, int solver_flags, int flags, int* changed);
#ifdef PAKFIRE_PRIVATE
#include <pakfire/config.h>
-int pakfire_on_root(Pakfire pakfire);
+int pakfire_on_root(struct pakfire* pakfire);
-void pakfire_log(Pakfire pakfire, int priority, const char *file,
+void pakfire_log(struct pakfire* pakfire, int priority, const char *file,
int line, const char *fn, const char *format, ...)
__attribute__((format(printf, 6, 7)));
-int pakfire_has_flag(Pakfire pakfire, int flag);
+int pakfire_has_flag(struct pakfire* pakfire, int flag);
-struct pakfire_config* pakfire_get_config(Pakfire pakfire);
-int pakfire_is_mountpoint(Pakfire pakfire, const char* path);
+struct pakfire_config* pakfire_get_config(struct pakfire* pakfire);
+int pakfire_is_mountpoint(struct pakfire* pakfire, const char* path);
-gpgme_ctx_t pakfire_get_gpgctx(Pakfire pakfire);
+gpgme_ctx_t pakfire_get_gpgctx(struct pakfire* pakfire);
-const char* pakfire_get_distro_name(Pakfire pakfire);
-const char* pakfire_get_distro_id(Pakfire pakfire);
-const char* pakfire_get_distro_vendor(Pakfire pakfire);
-const char* pakfire_get_distro_version(Pakfire pakfire);
-const char* pakfire_get_distro_version_id(Pakfire pakfire);
+const char* pakfire_get_distro_name(struct pakfire* pakfire);
+const char* pakfire_get_distro_id(struct pakfire* pakfire);
+const char* pakfire_get_distro_vendor(struct pakfire* pakfire);
+const char* pakfire_get_distro_version(struct pakfire* pakfire);
+const char* pakfire_get_distro_version_id(struct pakfire* pakfire);
#define pakfire_make_path(pakfire, dst, path) \
__pakfire_make_path(pakfire, dst, sizeof(dst) - 1, path)
-int __pakfire_make_path(Pakfire pakfire, char* dst, size_t length, const char* path);
+int __pakfire_make_path(struct pakfire* pakfire, char* dst, size_t length, const char* path);
#define pakfire_make_cache_path(pakfire, path, format, ...) \
__pakfire_make_cache_path(pakfire, path, sizeof(path) - 1, format, __VA_ARGS__)
-int __pakfire_make_cache_path(Pakfire pakfire, char* path, size_t length,
+int __pakfire_make_cache_path(struct pakfire* pakfire, char* path, size_t length,
const char* format, ...) __attribute__((format(printf, 4, 5)));
-void pakfire_pool_has_changed(Pakfire pakfire);
-void pakfire_pool_apply_changes(Pakfire pakfire);
+void pakfire_pool_has_changed(struct pakfire* pakfire);
+void pakfire_pool_apply_changes(struct pakfire* pakfire);
-Pool* pakfire_get_solv_pool(Pakfire pakfire);
+Pool* pakfire_get_solv_pool(struct pakfire* pakfire);
-struct pakfire_repo* pakfire_get_installed_repo(Pakfire pakfire);
+struct pakfire_repo* pakfire_get_installed_repo(struct pakfire* pakfire);
// Archive helpers
-struct archive* pakfire_make_archive_disk_reader(Pakfire pakfire, int internal);
-struct archive* pakfire_make_archive_disk_writer(Pakfire pakfire);
+struct archive* pakfire_make_archive_disk_reader(struct pakfire* pakfire, int internal);
+struct archive* pakfire_make_archive_disk_writer(struct pakfire* pakfire);
#endif
#include <pakfire/package.h>
#include <pakfire/parser.h>
#include <pakfire/repo.h>
-#include <pakfire/types.h>
enum pakfire_parser_flags {
PAKFIRE_PARSER_FLAGS_NONE = 0,
struct pakfire_parser_error;
-struct pakfire_parser* pakfire_parser_create(Pakfire pakfire, struct pakfire_parser* parser,
+struct pakfire_parser* pakfire_parser_create(struct pakfire* pakfire, struct pakfire_parser* parser,
const char* namespace, int flags);
struct pakfire_parser* pakfire_parser_create_child(struct pakfire_parser* parser,
const char* namespace);
int pakfire_parser_error_get_line(struct pakfire_parser_error* error);
const char* pakfire_parser_error_get_message(struct pakfire_parser_error* error);
-Pakfire pakfire_parser_get_pakfire(struct pakfire_parser* parser);
+struct pakfire* pakfire_parser_get_pakfire(struct pakfire_parser* parser);
struct pakfire_parser_declaration {
char namespace[NAME_MAX];
struct pakfire_problem;
#include <pakfire/solution.h>
-#include <pakfire/types.h>
struct pakfire_problem* pakfire_problem_ref(struct pakfire_problem* problem);
struct pakfire_problem* pakfire_problem_unref(struct pakfire_problem* problem);
#ifdef PAKFIRE_PRIVATE
-#include <solv/pooltypes.h>
#include <pakfire/request.h>
-int pakfire_problem_create(struct pakfire_problem** problem, Pakfire pakfire,
+int pakfire_problem_create(struct pakfire_problem** problem, struct pakfire* pakfire,
struct pakfire_request* request, Id id);
-Pakfire pakfire_problem_get_pakfire(struct pakfire_problem* problem);
+struct pakfire* pakfire_problem_get_pakfire(struct pakfire_problem* problem);
Id pakfire_problem_get_id(struct pakfire_problem* problem);
#endif
#include <grp.h>
#include <pwd.h>
-#include <pakfire/types.h>
-struct passwd* pakfire_getpwnam(Pakfire pakfire, const char* name);
-struct passwd* pakfire_getpwuid(Pakfire pakfire, uid_t uid);
+struct passwd* pakfire_getpwnam(struct pakfire* pakfire, const char* name);
+struct passwd* pakfire_getpwuid(struct pakfire* pakfire, uid_t uid);
-struct group* pakfire_getgrnam(Pakfire pakfire, const char* name);
-struct group* pakfire_getgrgid(Pakfire pakfire, gid_t gid);
+struct group* pakfire_getgrnam(struct pakfire* pakfire, const char* name);
+struct group* pakfire_getgrgid(struct pakfire* pakfire, gid_t gid);
#endif
#include <pakfire/archive.h>
#include <pakfire/package.h>
-#include <pakfire/types.h>
-struct pakfire_repo* pakfire_repo_create(Pakfire pakfire, const char* name);
+struct pakfire_repo* pakfire_repo_create(struct pakfire* pakfire, const char* name);
struct pakfire_repo* pakfire_repo_ref(struct pakfire_repo* repo);
struct pakfire_repo* pakfire_repo_unref(struct pakfire_repo* repo);
-Pakfire pakfire_repo_get_pakfire(struct pakfire_repo* repo);
+struct pakfire* pakfire_repo_get_pakfire(struct pakfire_repo* repo);
int pakfire_repo_clear(struct pakfire_repo* repo);
#include <pakfire/config.h>
#include <pakfire/downloader.h>
-int pakfire_repo_import(Pakfire pakfire, struct pakfire_config* config);
+int pakfire_repo_import(struct pakfire* pakfire, struct pakfire_config* config);
const char* pakfire_repo_get_path(struct pakfire_repo* repo);
void pakfire_repo_internalize(struct pakfire_repo* repo);
Id pakfire_repo_add_solvable(struct pakfire_repo* repo);
-struct pakfire_repo* pakfire_repo_create_from_repo(Pakfire pakfire, Repo* r);
-void pakfire_repo_free_all(Pakfire pakfire);
+struct pakfire_repo* pakfire_repo_create_from_repo(struct pakfire* pakfire, Repo* r);
+void pakfire_repo_free_all(struct pakfire* pakfire);
Repo* pakfire_repo_get_repo(struct pakfire_repo* repo);
Repodata* pakfire_repo_get_repodata(struct pakfire_repo* repo);
#define PAKFIRE_REPOLIST_H
#include <pakfire/repo.h>
-#include <pakfire/types.h>
struct pakfire_repolist;
#include <pakfire/problem.h>
#include <pakfire/solution.h>
#include <pakfire/transaction.h>
-#include <pakfire/types.h>
enum pakfire_request_flags {
PAKFIRE_REQUEST_WITHOUT_RECOMMENDED = 1 << 0,
PAKFIRE_REQUEST_KEEP_ORPHANED = 1 << 1,
};
-int pakfire_request_create(struct pakfire_request** request, Pakfire pakfire, int flags);
+int pakfire_request_create(struct pakfire_request** request, struct pakfire* pakfire, int flags);
struct pakfire_request* pakfire_request_ref(struct pakfire_request* request);
struct pakfire_request* pakfire_request_unref(struct pakfire_request* request);
#ifdef PAKFIRE_PRIVATE
-#include <pakfire/types.h>
extern const char* pakfire_scriptlet_types[13];
struct pakfire_scriptlet;
-int pakfire_scriptlet_create(struct pakfire_scriptlet** scriptlet, Pakfire pakfire,
+int pakfire_scriptlet_create(struct pakfire_scriptlet** scriptlet, struct pakfire* pakfire,
const char* type, const char* data, size_t size);
struct pakfire_scriptlet* pakfire_scriptlet_ref(struct pakfire_scriptlet* scriptlet);
struct pakfire_scriptlet* pakfire_scriptlet_unref(struct pakfire_scriptlet* scriptlet);
#include <stdio.h>
-#include <pakfire/types.h>
-int pakfire_snapshot_create(Pakfire pakfire, FILE* f);
-int pakfire_snapshot_restore(Pakfire pakfire, FILE* f);
+int pakfire_snapshot_create(struct pakfire* pakfire, FILE* f);
+int pakfire_snapshot_restore(struct pakfire* pakfire, FILE* f);
#endif
#ifdef PAKFIRE_PRIVATE
-#include <solv/pooltypes.h>
int pakfire_solution_create(struct pakfire_solution** solution,
struct pakfire_problem* problem, Id id);
#include <solv/solver.h>
-#include <pakfire/types.h>
int pakfire_transaction_create(struct pakfire_transaction** transaction,
- Pakfire pakfire, Solver* solver);
+ struct pakfire* pakfire, Solver* solver);
#endif
+++ /dev/null
-/*#############################################################################
-# #
-# Pakfire - The IPFire package management system #
-# Copyright (C) 2013 Pakfire development team #
-# #
-# This program is free software: you can redistribute it and/or modify #
-# it under the terms of the GNU General Public License as published by #
-# the Free Software Foundation, either version 3 of the License, or #
-# (at your option) any later version. #
-# #
-# This program is distributed in the hope that it will be useful, #
-# but WITHOUT ANY WARRANTY; without even the implied warranty of #
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
-# GNU General Public License for more details. #
-# #
-# You should have received a copy of the GNU General Public License #
-# along with this program. If not, see <http://www.gnu.org/licenses/>. #
-# #
-#############################################################################*/
-
-#ifndef PAKFIRE_TYPES_H
-#define PAKFIRE_TYPES_H
-
-typedef struct _Pakfire* Pakfire;
-
-#endif /* PAKFIRE_TYPES_H */
#include <pakfire/problem.h>
#include <pakfire/request.h>
-#include <pakfire/types.h>
-int pakfire_ui_confirm(Pakfire pakfire, const char* message, const char* question);
+int pakfire_ui_confirm(struct pakfire* pakfire, const char* message, const char* question);
-int pakfire_ui_pick_solution(Pakfire pakfire, struct pakfire_request* request,
+int pakfire_ui_pick_solution(struct pakfire* pakfire, struct pakfire_request* request,
struct pakfire_problem** problems);
#endif
#include <archive.h>
-#include <solv/pooltypes.h>
#include <pakfire/package.h>
-#include <pakfire/types.h>
-Id pakfire_parse_dep(Pakfire pakfire, const char* s);
-void pakfire_parse_deps(Pakfire pakfire, struct pakfire_package* pkg,
+Id pakfire_parse_dep(struct pakfire* pakfire, const char* s);
+void pakfire_parse_deps(struct pakfire* pakfire, struct pakfire_package* pkg,
void (*func)(struct pakfire_package* pkg, const char* dep), const char* deps);
#define pakfire_string_format(s, fmt, ...) snprintf(s, sizeof(s) - 1, fmt, __VA_ARGS__)
int pakfire_archive_copy_data(struct archive* src, struct archive* dst,
struct archive_entry* entry);
-int pakfire_archive_copy_data_to_buffer(Pakfire pakfire, struct archive* a,
+int pakfire_archive_copy_data_to_buffer(struct pakfire* pakfire, struct archive* a,
struct archive_entry* entry, char** data, size_t* data_size);
// JSON Stuff
-struct json_object* pakfire_json_parse_from_file(Pakfire pakfire, const char* path);
+struct json_object* pakfire_json_parse_from_file(struct pakfire* pakfire, const char* path);
// Time Stuff
#define PAKFIRE_RLIMIT_NOFILE_MAX (512 * 1024)
-int pakfire_rlimit_set(Pakfire pakfire, int limit);
-int pakfire_rlimit_reset_nofile(Pakfire pakfire);
+int pakfire_rlimit_set(struct pakfire* pakfire, int limit);
+int pakfire_rlimit_reset_nofile(struct pakfire* pakfire);
#endif
#include <pakfire/util.h>
struct pakfire_key {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
gpgme_key_t gpgkey;
};
-int pakfire_key_create(struct pakfire_key** key, Pakfire pakfire, gpgme_key_t gpgkey) {
+int pakfire_key_create(struct pakfire_key** key, struct pakfire* pakfire, gpgme_key_t gpgkey) {
if (!gpgkey) {
errno = EINVAL;
return 1;
return 0;
}
-static int __pakfire_key_fetch(gpgme_key_t* key, Pakfire pakfire,
+static int __pakfire_key_fetch(gpgme_key_t* key, struct pakfire* pakfire,
const char* what, gpgme_keylist_mode_t flags) {
// Fetch GPGME context
gpgme_ctx_t gpgctx = pakfire_get_gpgctx(pakfire);
return r;
}
-static int pakfire_key_fetch_from_wkd(gpgme_key_t* key, Pakfire pakfire, const char* email) {
+static int pakfire_key_fetch_from_wkd(gpgme_key_t* key, struct pakfire* pakfire, const char* email) {
return __pakfire_key_fetch(key, pakfire, email, GPGME_KEYLIST_MODE_LOCATE);
}
-static int pakfire_key_fetch_from_keyserver(gpgme_key_t* key, Pakfire pakfire, const char* fpr) {
+static int pakfire_key_fetch_from_keyserver(gpgme_key_t* key, struct pakfire* pakfire, const char* fpr) {
return __pakfire_key_fetch(key, pakfire, fpr, GPGME_KEYLIST_MODE_EXTERN);
}
-PAKFIRE_EXPORT int pakfire_key_fetch(struct pakfire_key** key, Pakfire pakfire,
+PAKFIRE_EXPORT int pakfire_key_fetch(struct pakfire_key** key, struct pakfire* pakfire,
const char* uid, const char* fingerprint) {
// At least one (uid or fingerprint) must be set
if (!uid && !fingerprint) {
pakfire_key_free(key);
}
-static int pakfire_find_key(struct pakfire_key** key, Pakfire pakfire, const char* fingerprint) {
+static int pakfire_find_key(struct pakfire_key** key, struct pakfire* pakfire, const char* fingerprint) {
// Reset key
*key = NULL;
return 0;
}
-PAKFIRE_EXPORT struct pakfire_key* pakfire_key_get(Pakfire pakfire, const char* fingerprint) {
+PAKFIRE_EXPORT struct pakfire_key* pakfire_key_get(struct pakfire* pakfire, const char* fingerprint) {
struct pakfire_key* key = NULL;
int r = pakfire_find_key(&key, pakfire, fingerprint);
return 0;
}
-PAKFIRE_EXPORT int pakfire_key_generate(struct pakfire_key** key, Pakfire pakfire,
+PAKFIRE_EXPORT int pakfire_key_generate(struct pakfire_key** key, struct pakfire* pakfire,
const char* algo, const char* userid) {
// Reset key
*key = NULL;
return r;
}
-PAKFIRE_EXPORT int pakfire_key_import(Pakfire pakfire, FILE* f,
+PAKFIRE_EXPORT int pakfire_key_import(struct pakfire* pakfire, FILE* f,
struct pakfire_key*** keys) {
gpgme_data_t data;
int r = 1;
#include <solv/evr.h>
#include <solv/pool.h>
-#include <solv/pooltypes.h>
#include <solv/repo.h>
#include <solv/solvable.h>
#include <pakfire/util.h>
struct pakfire_package {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
// Reference to this package in the SOLV pool
char path[PATH_MAX];
};
-static void pakfire_package_add_self_provides(Pakfire pakfire, struct pakfire_package* pkg, const char* name, const char* evr) {
+static void pakfire_package_add_self_provides(struct pakfire* pakfire, struct pakfire_package* pkg, const char* name, const char* evr) {
char buffer[1024];
pakfire_string_format(buffer, "%s = %s", name, evr);
pakfire_package_add_provides(pkg, buffer);
}
-struct pakfire_package* pakfire_package_create_from_solvable(Pakfire pakfire, Id id) {
+struct pakfire_package* pakfire_package_create_from_solvable(struct pakfire* pakfire, Id id) {
struct pakfire_package* pkg = calloc(1, sizeof(*pkg));
if (!pkg)
return NULL;
return pkg;
}
-PAKFIRE_EXPORT struct pakfire_package* pakfire_package_create(Pakfire pakfire, struct pakfire_repo* repo, const char* name, const char* evr, const char* arch) {
+PAKFIRE_EXPORT struct pakfire_package* pakfire_package_create(struct pakfire* pakfire, struct pakfire_repo* repo, const char* name, const char* evr, const char* arch) {
Id id = pakfire_repo_add_solvable(repo);
if (!id)
return NULL;
return NULL;
}
-PAKFIRE_EXPORT Pakfire pakfire_package_get_pakfire(struct pakfire_package* pkg) {
+PAKFIRE_EXPORT struct pakfire* pakfire_package_get_pakfire(struct pakfire_package* pkg) {
return pakfire_ref(pkg->pakfire);
}
#include <stdlib.h>
#include <solv/pool.h>
-#include <solv/pooltypes.h>
#include <solv/solver.h>
#include <solv/util.h>
#include <pakfire/packagelist.h>
#include <pakfire/pakfire.h>
#include <pakfire/private.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
#define BLOCK_SIZE 31
struct pakfire_packagelist {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
struct pakfire_package** elements;
}
PAKFIRE_EXPORT int pakfire_packagelist_create(
- struct pakfire_packagelist** list, Pakfire pakfire) {
+ struct pakfire_packagelist** list, struct pakfire* pakfire) {
struct pakfire_packagelist* l = calloc(1, sizeof(*l));
if (!l)
return 1;
return 0;
}
-int pakfire_packagelist_create_from_queue(struct pakfire_packagelist** list, Pakfire pakfire, Queue* q) {
+int pakfire_packagelist_create_from_queue(struct pakfire_packagelist** list, struct pakfire* pakfire, Queue* q) {
// Create a new package list
int r = pakfire_packagelist_create(list, pakfire);
if (r)
#include <pakfire/packager.h>
#include <pakfire/pakfire.h>
#include <pakfire/pwd.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
#define BUFFER_SIZE 64 * 1024
struct pakfire_packager {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
time_t time_created;
unsigned int num_scriptlets;
};
-static int pakfire_packager_create_mtree(Pakfire pakfire, struct archive** mtree,
+static int pakfire_packager_create_mtree(struct pakfire* pakfire, struct archive** mtree,
FILE** f, const char** fields) {
char path[] = PAKFIRE_PRIVATE_DIR "/tmp/.pakfire-mtree.XXXXXX";
int r;
#include <pakfire/repo.h>
#include <pakfire/request.h>
#include <pakfire/transaction.h>
-#include <pakfire/types.h>
#include <pakfire/ui.h>
#include <pakfire/util.h>
char path[PATH_MAX];
};
-struct _Pakfire {
+struct pakfire {
char path[PATH_MAX];
char cache_path[PATH_MAX];
char arch[ARCH_MAX];
{ NULL },
};
-int pakfire_on_root(Pakfire pakfire) {
+int pakfire_on_root(struct pakfire* pakfire) {
return (strcmp(pakfire->path, "/") == 0);
}
{ NULL },
};
-static int __mount(Pakfire pakfire, const char* source, const char* target,
+static int __mount(struct pakfire* pakfire, const char* source, const char* target,
const char* filesystemtype, unsigned long mountflags, const void* data) {
int r = mount(source, target, filesystemtype, mountflags, data);
if (r)
return 0;
}
-static int pakfire_mount(Pakfire pakfire) {
+static int pakfire_mount(struct pakfire* pakfire) {
char target[PATH_MAX];
int r;
return 0;
}
-static int pakfire_umount(Pakfire pakfire) {
+static int pakfire_umount(struct pakfire* pakfire) {
struct mountpoint* mp;
int r;
int flags = 0;
return 0;
}
-int pakfire_is_mountpoint(Pakfire pakfire, const char* path) {
+int pakfire_is_mountpoint(struct pakfire* pakfire, const char* path) {
struct mountpoint* mp;
// Check if path is on this list
{ NULL },
};
-static int pakfire_populate_dev(Pakfire pakfire) {
+static int pakfire_populate_dev(struct pakfire* pakfire) {
char path[PATH_MAX];
// Create device nodes
return 0;
}
-static void pakfire_log_set_function(Pakfire pakfire,
+static void pakfire_log_set_function(struct pakfire* pakfire,
pakfire_log_function_t log_function, void* data) {
pakfire->log_function = log_function;
pakfire->log_data = data;
}
static void pool_log(Pool* pool, void* data, int type, const char* s) {
- Pakfire pakfire = (Pakfire)data;
+ struct pakfire* pakfire = (struct pakfire*)data;
DEBUG(pakfire, "pool: %s", s);
}
static Id pakfire_namespace_callback(Pool* pool, void* data, Id ns, Id id) {
- Pakfire pakfire = (Pakfire)data;
+ struct pakfire* pakfire = (struct pakfire*)data;
const char* namespace = pool_id2str(pool, ns);
const char* name = pool_dep2str(pool, id);
return 0;
}
-static int pakfire_populate_pool(Pakfire pakfire) {
+static int pakfire_populate_pool(struct pakfire* pakfire) {
struct pakfire_db* db;
struct pakfire_repo* repo = NULL;
struct pakfire_repo* dummy = NULL;
return r;
}
-static int pakfire_mount_interpreter(Pakfire pakfire) {
+static int pakfire_mount_interpreter(struct pakfire* pakfire) {
char target[PATH_MAX];
// Can we emulate this architecture?
return r;
}
-static void pakfire_free(Pakfire pakfire) {
+static void pakfire_free(struct pakfire* pakfire) {
// Release GPGME context
if (pakfire->gpgctx)
gpgme_release(pakfire->gpgctx);
}
// Safety check in case this is being launched on the host system
-static int pakfire_safety_checks(Pakfire pakfire) {
+static int pakfire_safety_checks(struct pakfire* pakfire) {
// Nothing to do if we are not working on root
if (!pakfire_on_root(pakfire))
return 0;
return 0;
}
-static int pakfire_read_repo_config(Pakfire pakfire) {
+static int pakfire_read_repo_config(struct pakfire* pakfire) {
char path[PATH_MAX];
int r = pakfire_make_path(pakfire, path, PAKFIRE_CONFIG_PATH "/repos");
return r;
}
-const char* pakfire_get_distro_name(Pakfire pakfire) {
+const char* pakfire_get_distro_name(struct pakfire* pakfire) {
if (*pakfire->distro.name)
return pakfire->distro.name;
return NULL;
}
-const char* pakfire_get_distro_id(Pakfire pakfire) {
+const char* pakfire_get_distro_id(struct pakfire* pakfire) {
if (*pakfire->distro.id)
return pakfire->distro.id;
return NULL;
}
-const char* pakfire_get_distro_vendor(Pakfire pakfire) {
+const char* pakfire_get_distro_vendor(struct pakfire* pakfire) {
if (*pakfire->distro.vendor)
return pakfire->distro.vendor;
return NULL;
}
-const char* pakfire_get_distro_version(Pakfire pakfire) {
+const char* pakfire_get_distro_version(struct pakfire* pakfire) {
if (*pakfire->distro.version)
return pakfire->distro.version;
return NULL;
}
-const char* pakfire_get_distro_version_id(Pakfire pakfire) {
+const char* pakfire_get_distro_version_id(struct pakfire* pakfire) {
if (*pakfire->distro.version_id)
return pakfire->distro.version_id;
return NULL;
}
-static int pakfire_config_import_distro(Pakfire pakfire) {
+static int pakfire_config_import_distro(struct pakfire* pakfire) {
// Nothing to do if there is no distro section
if (!pakfire_config_has_section(pakfire->config, "distro"))
return 0;
return 0;
}
-static int pakfire_read_config(Pakfire pakfire, const char* path) {
+static int pakfire_read_config(struct pakfire* pakfire, const char* path) {
char default_path[PATH_MAX];
// Use default path if none set
return r;
}
-static int pakfire_read_os_release(Pakfire pakfire) {
+static int pakfire_read_os_release(struct pakfire* pakfire) {
char path[PATH_MAX];
char* line = NULL;
size_t l = 0;
return r;
}
-PAKFIRE_EXPORT int pakfire_create(Pakfire* pakfire, const char* path, const char* arch,
- const char* conf, int flags, pakfire_log_function_t log, void* data) {
+PAKFIRE_EXPORT int pakfire_create(struct pakfire** pakfire, const char* path,
+ const char* arch, const char* conf, int flags, pakfire_log_function_t log,
+ void* data) {
char tempdir[PATH_MAX] = PAKFIRE_PRIVATE_DIR "/tmp/XXXXXX";
int r = 1;
return 1;
}
- Pakfire p = calloc(1, sizeof(*p));
+ struct pakfire* p = calloc(1, sizeof(*p));
if (!p)
return 1;
return r;
}
-PAKFIRE_EXPORT Pakfire pakfire_ref(Pakfire pakfire) {
+PAKFIRE_EXPORT struct pakfire* pakfire_ref(struct pakfire* pakfire) {
++pakfire->nrefs;
return pakfire;
}
-PAKFIRE_EXPORT Pakfire pakfire_unref(Pakfire pakfire) {
+PAKFIRE_EXPORT struct pakfire* pakfire_unref(struct pakfire* pakfire) {
if (--pakfire->nrefs > 0)
return pakfire;
return NULL;
}
-int pakfire_has_flag(Pakfire pakfire, int flag) {
+int pakfire_has_flag(struct pakfire* pakfire, int flag) {
return pakfire->flags & flag;
}
-struct pakfire_config* pakfire_get_config(Pakfire pakfire) {
+struct pakfire_config* pakfire_get_config(struct pakfire* pakfire) {
if (!pakfire->config)
return NULL;
return pakfire_config_ref(pakfire->config);
}
-PAKFIRE_EXPORT const char* pakfire_get_path(Pakfire pakfire) {
+PAKFIRE_EXPORT const char* pakfire_get_path(struct pakfire* pakfire) {
return pakfire->path;
}
-int __pakfire_make_path(Pakfire pakfire, char* dst, size_t length, const char* path) {
+int __pakfire_make_path(struct pakfire* pakfire, char* dst, size_t length, const char* path) {
// Make sure that path never starts with /
while (path && *path == '/')
path++;
return __pakfire_path_join(dst, length, pakfire->path, path);
}
-PAKFIRE_EXPORT int pakfire_bind(Pakfire pakfire, const char* src, const char* dst, int flags) {
+PAKFIRE_EXPORT int pakfire_bind(struct pakfire* pakfire, const char* src, const char* dst, int flags) {
struct stat st;
char mountpoint[PATH_MAX];
return __mount(pakfire, src, mountpoint, NULL, flags|MS_BIND, NULL);
}
-static int pakfire_init_gpgme(Pakfire pakfire) {
+static int pakfire_init_gpgme(struct pakfire* pakfire) {
static int gpgme_initialized = 0;
// Do nothing if gpgme is already initialized
return 0;
}
-gpgme_ctx_t pakfire_get_gpgctx(Pakfire pakfire) {
+gpgme_ctx_t pakfire_get_gpgctx(struct pakfire* pakfire) {
int r = pakfire_init_gpgme(pakfire);
if (r)
return NULL;
return NULL;
}
-PAKFIRE_EXPORT int pakfire_list_keys(Pakfire pakfire, struct pakfire_key*** keys) {
+PAKFIRE_EXPORT int pakfire_list_keys(struct pakfire* pakfire, struct pakfire_key*** keys) {
// Reset keys
*keys = NULL;
return r;
}
-static int pakfire_foreach_repo(Pakfire pakfire,
+static int pakfire_foreach_repo(struct pakfire* pakfire,
int (*func)(struct pakfire_repo* repo, int flags), int flags) {
struct pakfire_repo* repo;
return 0;
}
-PAKFIRE_EXPORT int pakfire_clean(Pakfire pakfire, int flags) {
+PAKFIRE_EXPORT int pakfire_clean(struct pakfire* pakfire, int flags) {
return pakfire_foreach_repo(pakfire, pakfire_repo_clean, flags);
}
-PAKFIRE_EXPORT int pakfire_refresh(Pakfire pakfire, int flags) {
+PAKFIRE_EXPORT int pakfire_refresh(struct pakfire* pakfire, int flags) {
// Do nothing if running in offline mode
if (pakfire_has_flag(pakfire, PAKFIRE_FLAGS_OFFLINE))
return 0;
return pakfire_foreach_repo(pakfire, pakfire_repo_refresh, flags);
}
-static int pakfire_copy(Pakfire pakfire, const char* src, const char* dst) {
+static int pakfire_copy(struct pakfire* pakfire, const char* src, const char* dst) {
char buffer[512 * 1024];
struct archive* reader = NULL;
struct archive* writer = NULL;
return r;
}
-PAKFIRE_EXPORT int pakfire_copy_in(Pakfire pakfire, const char* src, const char* dst) {
+PAKFIRE_EXPORT int pakfire_copy_in(struct pakfire* pakfire, const char* src, const char* dst) {
if (pakfire_on_root(pakfire)) {
errno = ENOTSUP;
return 1;
return pakfire_copy(pakfire, src, path);
}
-PAKFIRE_EXPORT int pakfire_copy_out(Pakfire pakfire, const char* src, const char* dst) {
+PAKFIRE_EXPORT int pakfire_copy_out(struct pakfire* pakfire, const char* src, const char* dst) {
if (pakfire_on_root(pakfire)) {
errno = ENOTSUP;
return 1;
return pakfire_copy(pakfire, path, dst);
}
-PAKFIRE_EXPORT const char* pakfire_get_arch(Pakfire pakfire) {
+PAKFIRE_EXPORT const char* pakfire_get_arch(struct pakfire* pakfire) {
return pakfire->arch;
}
-PAKFIRE_EXPORT int pakfire_version_compare(Pakfire pakfire, const char* evr1, const char* evr2) {
+PAKFIRE_EXPORT int pakfire_version_compare(struct pakfire* pakfire, const char* evr1, const char* evr2) {
return pool_evrcmp_str(pakfire->pool, evr1, evr2, EVRCMP_COMPARE);
}
-Pool* pakfire_get_solv_pool(Pakfire pakfire) {
+Pool* pakfire_get_solv_pool(struct pakfire* pakfire) {
return pakfire->pool;
}
-void pakfire_pool_has_changed(Pakfire pakfire) {
+void pakfire_pool_has_changed(struct pakfire* pakfire) {
pakfire->pool_ready = 0;
}
-void pakfire_pool_apply_changes(Pakfire pakfire) {
+void pakfire_pool_apply_changes(struct pakfire* pakfire) {
if (!pakfire->pool_ready) {
pool_addfileprovides(pakfire->pool);
pool_createwhatprovides(pakfire->pool);
}
}
-PAKFIRE_EXPORT struct pakfire_repolist* pakfire_get_repos(Pakfire pakfire) {
+PAKFIRE_EXPORT struct pakfire_repolist* pakfire_get_repos(struct pakfire* pakfire) {
struct pakfire_repolist* list;
int r = pakfire_repolist_create(&list);
return NULL;
}
-PAKFIRE_EXPORT struct pakfire_repo* pakfire_get_repo(Pakfire pakfire, const char* name) {
+PAKFIRE_EXPORT struct pakfire_repo* pakfire_get_repo(struct pakfire* pakfire, const char* name) {
Pool* pool = pakfire_get_solv_pool(pakfire);
Repo* repo;
return NULL;
}
-struct pakfire_repo* pakfire_get_installed_repo(Pakfire pakfire) {
+struct pakfire_repo* pakfire_get_installed_repo(struct pakfire* pakfire) {
if (!pakfire->pool->installed)
return NULL;
return pakfire_repo_create_from_repo(pakfire, pakfire->pool->installed);
}
-static int pakfire_search_dep(Pakfire pakfire, Id type, const char* what, int flags,
+static int pakfire_search_dep(struct pakfire* pakfire, Id type, const char* what, int flags,
struct pakfire_packagelist** list) {
// Refresh repositories
int r = pakfire_refresh(pakfire, 0);
return r;
}
-PAKFIRE_EXPORT int pakfire_whatprovides(Pakfire pakfire, const char* what, int flags,
+PAKFIRE_EXPORT int pakfire_whatprovides(struct pakfire* pakfire, const char* what, int flags,
struct pakfire_packagelist** list) {
return pakfire_search_dep(pakfire, SOLVABLE_PROVIDES, what, flags, list);
}
-PAKFIRE_EXPORT int pakfire_whatrequires(Pakfire pakfire, const char* what, int flags,
+PAKFIRE_EXPORT int pakfire_whatrequires(struct pakfire* pakfire, const char* what, int flags,
struct pakfire_packagelist** list) {
return pakfire_search_dep(pakfire, SOLVABLE_REQUIRES, what, flags, list);
}
-PAKFIRE_EXPORT int pakfire_search(Pakfire pakfire, const char* what, int flags,
+PAKFIRE_EXPORT int pakfire_search(struct pakfire* pakfire, const char* what, int flags,
struct pakfire_packagelist** list) {
Queue matches;
Dataiterator di;
// Cache
-int __pakfire_make_cache_path(Pakfire pakfire, char* path, size_t length,
+int __pakfire_make_cache_path(struct pakfire* pakfire, char* path, size_t length,
const char* format, ...) {
va_list args;
return 0;
}
-PAKFIRE_EXPORT int pakfire_log_get_priority(Pakfire pakfire) {
+PAKFIRE_EXPORT int pakfire_log_get_priority(struct pakfire* pakfire) {
return pakfire->log_priority;
}
-PAKFIRE_EXPORT void pakfire_log_set_priority(Pakfire pakfire, int priority) {
+PAKFIRE_EXPORT void pakfire_log_set_priority(struct pakfire* pakfire, int priority) {
pakfire->log_priority = priority;
}
-void pakfire_log(Pakfire pakfire, int priority, const char* file, int line,
+void pakfire_log(struct pakfire* pakfire, int priority, const char* file, int line,
const char* fn, const char* format, ...) {
va_list args;
}
static const char* pakfire_user_lookup(void* data, la_int64_t uid) {
- Pakfire pakfire = (Pakfire)data;
+ struct pakfire* pakfire = (struct pakfire*)data;
// Fast path for "root"
if (uid == 0)
}
static const char* pakfire_group_lookup(void* data, la_int64_t gid) {
- Pakfire pakfire = (Pakfire)data;
+ struct pakfire* pakfire = (struct pakfire*)data;
// Fast path for "root"
if (gid == 0)
return entry->gr_name;
}
-struct archive* pakfire_make_archive_disk_reader(Pakfire pakfire, int internal) {
+struct archive* pakfire_make_archive_disk_reader(struct pakfire* pakfire, int internal) {
struct archive* archive = archive_read_disk_new();
if (!archive)
return NULL;
}
static la_int64_t pakfire_uid_lookup(void* data, const char* name, la_int64_t uid) {
- Pakfire pakfire = (Pakfire)data;
+ struct pakfire* pakfire = (struct pakfire*)data;
// Fast path for "root"
if (strcmp(name, "root") == 0)
}
static la_int64_t pakfire_gid_lookup(void* data, const char* name, la_int64_t uid) {
- Pakfire pakfire = (Pakfire)data;
+ struct pakfire* pakfire = (struct pakfire*)data;
// Fast path for "root"
if (strcmp(name, "root") == 0)
return entry->gr_gid;
}
-struct archive* pakfire_make_archive_disk_writer(Pakfire pakfire) {
+struct archive* pakfire_make_archive_disk_writer(struct pakfire* pakfire) {
struct archive* archive = archive_write_disk_new();
if (!archive)
return NULL;
// Convenience functions to install/erase/update packages
-static int pakfire_perform_transaction(Pakfire pakfire, int solver_flags,
+static int pakfire_perform_transaction(struct pakfire* pakfire, int solver_flags,
int (*action)(struct pakfire_request* request, const char* what, int flags),
const char** packages, const char** locks, int job_flags, int* changed) {
struct pakfire_request* request = NULL;
return r;
}
-PAKFIRE_EXPORT int pakfire_install(Pakfire pakfire, int solver_flags,
+PAKFIRE_EXPORT int pakfire_install(struct pakfire* pakfire, int solver_flags,
const char** packages, const char** locks, int flags, int* changed) {
return pakfire_perform_transaction(pakfire, solver_flags, pakfire_request_install,
packages, locks, flags, changed);
}
-PAKFIRE_EXPORT int pakfire_erase(Pakfire pakfire, int solver_flags,
+PAKFIRE_EXPORT int pakfire_erase(struct pakfire* pakfire, int solver_flags,
const char** packages, const char** locks, int flags, int* changed) {
return pakfire_perform_transaction(pakfire, solver_flags, pakfire_request_erase,
packages, locks, flags, changed);
}
-static int pakfire_perform_transaction_simple(Pakfire pakfire, int solver_flags,
+static int pakfire_perform_transaction_simple(struct pakfire* pakfire, int solver_flags,
int (*action)(struct pakfire_request* request, int flags),
int job_flags, int* changed) {
struct pakfire_request* request = NULL;
return r;
}
-PAKFIRE_EXPORT int pakfire_update(Pakfire pakfire, int solver_flags,
+PAKFIRE_EXPORT int pakfire_update(struct pakfire* pakfire, int solver_flags,
const char** packages, const char** locks, int flags, int* changed) {
// If no packages are being passed, we will try to update everything
// XXX add locks
packages, locks, flags, changed);
}
-static int pakfire_verify(Pakfire pakfire, int *changed) {
+static int pakfire_verify(struct pakfire* pakfire, int *changed) {
return pakfire_perform_transaction_simple(pakfire, 0, pakfire_request_verify, 0, changed);
}
-PAKFIRE_EXPORT int pakfire_check(Pakfire pakfire) {
+PAKFIRE_EXPORT int pakfire_check(struct pakfire* pakfire) {
struct pakfire_db* db = NULL;
int r;
return r;
}
-PAKFIRE_EXPORT int pakfire_sync(Pakfire pakfire, int solver_flags, int flags, int* changed) {
+PAKFIRE_EXPORT int pakfire_sync(struct pakfire* pakfire, int solver_flags, int flags, int* changed) {
return pakfire_perform_transaction_simple(pakfire, solver_flags,
pakfire_request_sync, flags, changed);
}
#include <pakfire/util.h>
struct pakfire_parser {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
struct pakfire_parser* parent;
return 0;
}
-struct pakfire_parser* pakfire_parser_create(Pakfire pakfire,
+struct pakfire_parser* pakfire_parser_create(struct pakfire* pakfire,
struct pakfire_parser* parent, const char* namespace, int flags) {
struct pakfire_parser* parser = calloc(1, sizeof(*parser));
if (parser) {
return parser;
}
-Pakfire pakfire_parser_get_pakfire(struct pakfire_parser* parser) {
+struct pakfire* pakfire_parser_get_pakfire(struct pakfire_parser* parser) {
return pakfire_ref(parser->pakfire);
}
%parse-param
{yyscan_t* scanner}
- {Pakfire pakfire}
+ {struct pakfire* pakfire}
{struct pakfire_parser** parser}
{struct pakfire_parser* parent}
{struct pakfire_parser_error** error}
#include <pakfire/constants.h>
#include <pakfire/logging.h>
+#include <pakfire/pakfire.h>
#include <pakfire/parser.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
#define YYERROR_VERBOSE 1
OP_EQUALS = 0,
};
-static void yyerror(yyscan_t* scanner, Pakfire pakfire, struct pakfire_parser** parser,
+static void yyerror(yyscan_t* scanner, struct pakfire* pakfire, struct pakfire_parser** parser,
struct pakfire_parser* parent, struct pakfire_parser_error** error, const char* s) {
ERROR(pakfire, "Error (line %d): %s\n", num_lines, s);
}
}
-static struct pakfire_parser* make_if_stmt(Pakfire pakfire, const enum operator op,
+static struct pakfire_parser* make_if_stmt(struct pakfire* pakfire, const enum operator op,
const char* val1, const char* val2, struct pakfire_parser* if_block, struct pakfire_parser* else_block);
static int pakfire_parser_new_declaration(
int pakfire_parser_parse_data(struct pakfire_parser* parent, const char* data, size_t len,
struct pakfire_parser_error** error) {
- Pakfire pakfire = pakfire_parser_get_pakfire(parent);
+ struct pakfire* pakfire = pakfire_parser_get_pakfire(parent);
yyscan_t scanner;
#ifdef ENABLE_DEBUG
return r;
}
-static struct pakfire_parser* make_if_stmt(Pakfire pakfire, const enum operator op,
+static struct pakfire_parser* make_if_stmt(struct pakfire* pakfire, const enum operator op,
const char* val1, const char* val2, struct pakfire_parser* if_block, struct pakfire_parser* else_block) {
switch (op) {
case OP_EQUALS:
int num_lines;
#include <ctype.h>
+#include <stdint.h>
#include <stdlib.h>
#include <pakfire/parser.h>
#include <pakfire/util.h>
struct pakfire_problem {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
struct pakfire_request* request;
}
PAKFIRE_EXPORT int pakfire_problem_create(struct pakfire_problem** problem,
- Pakfire pakfire, struct pakfire_request* request, Id id) {
+ struct pakfire* pakfire, struct pakfire_request* request, Id id) {
struct pakfire_problem* p = calloc(1, sizeof(*p));
if (!p)
return 1;
return NULL;
}
-Pakfire pakfire_problem_get_pakfire(struct pakfire_problem* problem) {
+struct pakfire* pakfire_problem_get_pakfire(struct pakfire_problem* problem) {
return pakfire_ref(problem->pakfire);
}
#include <pakfire/pakfire.h>
#include <pakfire/pwd.h>
-static struct passwd* pakfire_getpwent(Pakfire pakfire,
+static struct passwd* pakfire_getpwent(struct pakfire* pakfire,
int(*cmp)(struct passwd* entry, const void* value), const void* value) {
struct passwd* entry = NULL;
char path[PATH_MAX];
return 0;
}
-struct passwd* pakfire_getpwnam(Pakfire pakfire, const char* name) {
+struct passwd* pakfire_getpwnam(struct pakfire* pakfire, const char* name) {
return pakfire_getpwent(pakfire, __pakfire_getpwnam, name);
}
return 0;
}
-struct passwd* pakfire_getpwuid(Pakfire pakfire, uid_t uid) {
+struct passwd* pakfire_getpwuid(struct pakfire* pakfire, uid_t uid) {
return pakfire_getpwent(pakfire, __pakfire_getpwuid, &uid);
}
-static struct group* pakfire_getgrent(Pakfire pakfire,
+static struct group* pakfire_getgrent(struct pakfire* pakfire,
int(*cmp)(struct group* entry, const void* value), const void* value) {
struct group* entry = NULL;
char path[PATH_MAX];
return 0;
}
-struct group* pakfire_getgrnam(Pakfire pakfire, const char* name) {
+struct group* pakfire_getgrnam(struct pakfire* pakfire, const char* name) {
return pakfire_getgrent(pakfire, __pakfire_getgrnam, name);
}
return 0;
}
-struct group* pakfire_getgrgid(Pakfire pakfire, gid_t gid) {
+struct group* pakfire_getgrgid(struct pakfire* pakfire, gid_t gid) {
return pakfire_getgrent(pakfire, __pakfire_getgrgid, &gid);
}
#include <pakfire/private.h>
#include <pakfire/progressbar.h>
#include <pakfire/repo.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
// Refresh mirrorlists once a day
};
struct pakfire_repo {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
Repo* repo;
return (*name == '@');
}
-int pakfire_repo_import(Pakfire pakfire, struct pakfire_config* config) {
+int pakfire_repo_import(struct pakfire* pakfire, struct pakfire_config* config) {
char** sections = pakfire_config_sections(config);
// The configuration seems to be empty
free(repo);
}
-void pakfire_repo_free_all(Pakfire pakfire) {
+void pakfire_repo_free_all(struct pakfire* pakfire) {
Pool* pool = pakfire_get_solv_pool(pakfire);
if (!pool)
return;
}
}
-PAKFIRE_EXPORT struct pakfire_repo* pakfire_repo_create(Pakfire pakfire, const char* name) {
+PAKFIRE_EXPORT struct pakfire_repo* pakfire_repo_create(struct pakfire* pakfire, const char* name) {
struct pakfire_repo* repo;
int r;
return NULL;
}
-struct pakfire_repo* pakfire_repo_create_from_repo(Pakfire pakfire, Repo* r) {
+struct pakfire_repo* pakfire_repo_create_from_repo(struct pakfire* pakfire, Repo* r) {
struct pakfire_repo* repo = calloc(1, sizeof(*repo));
if (repo) {
DEBUG(pakfire, "Allocated Repo at %p\n", repo);
return NULL;
}
-PAKFIRE_EXPORT Pakfire pakfire_repo_get_pakfire(struct pakfire_repo* repo) {
+PAKFIRE_EXPORT struct pakfire* pakfire_repo_get_pakfire(struct pakfire_repo* repo) {
return pakfire_ref(repo->pakfire);
}
#include <pakfire/private.h>
#include <pakfire/repo.h>
#include <pakfire/repolist.h>
-#include <pakfire/types.h>
struct pakfire_repolist {
int nrefs;
#include <pakfire/problem.h>
#include <pakfire/request.h>
#include <pakfire/transaction.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
struct pakfire_request {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
Solver* solver;
}
PAKFIRE_EXPORT int pakfire_request_create(struct pakfire_request** request,
- Pakfire pakfire, int flags) {
+ struct pakfire* pakfire, int flags) {
Pool* pool = pakfire_get_solv_pool(pakfire);
int r = 1;
#include <pakfire/execute.h>
#include <pakfire/logging.h>
#include <pakfire/scriptlet.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
const char* pakfire_scriptlet_types[] = {
};
struct pakfire_scriptlet {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
// Type
free(scriptlet);
}
-int pakfire_scriptlet_create(struct pakfire_scriptlet** scriptlet, Pakfire pakfire,
+int pakfire_scriptlet_create(struct pakfire_scriptlet** scriptlet, struct pakfire* pakfire,
const char* type, const char* data, size_t size) {
if (!type || !data) {
errno = EINVAL;
#include <pakfire/progressbar.h>
#include <pakfire/repo.h>
#include <pakfire/snapshot.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
static int pakfire_snapshot_progressbar(
return 1;
}
-static struct archive* pakfire_snapshot_create_archive(Pakfire pakfire, FILE* f) {
+static struct archive* pakfire_snapshot_create_archive(struct pakfire* pakfire, FILE* f) {
struct archive* a = archive_write_new();
if (!a) {
ERROR(pakfire, "archive_write_new() failed\n");
return NULL;
}
-int pakfire_snapshot_create(Pakfire pakfire, FILE* f) {
+int pakfire_snapshot_create(struct pakfire* pakfire, FILE* f) {
int r = 1;
const char* root = pakfire_get_path(pakfire);
return r;
}
-static int pakfire_snapshot_extract(Pakfire pakfire, FILE* f) {
+static int pakfire_snapshot_extract(struct pakfire* pakfire, FILE* f) {
struct pakfire_progressbar* progressbar = NULL;
char buffer[PATH_MAX];
struct stat st;
return r;
}
-int pakfire_snapshot_restore(Pakfire pakfire, FILE* f) {
+int pakfire_snapshot_restore(struct pakfire* pakfire, FILE* f) {
struct pakfire_db* db = NULL;
// Extract the archive
#include <pakfire/util.h>
struct pakfire_solution {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
struct pakfire_problem* problem;
#include <pakfire/private.h>
#include <pakfire/repo.h>
#include <pakfire/transaction.h>
-#include <pakfire/types.h>
#include <pakfire/ui.h>
#include <pakfire/util.h>
struct pakfire_transaction {
- Pakfire pakfire;
+ struct pakfire* pakfire;
int nrefs;
Transaction* transaction;
}
int pakfire_transaction_create(struct pakfire_transaction** transaction,
- Pakfire pakfire, Solver* solver) {
+ struct pakfire* pakfire, Solver* solver) {
struct pakfire_transaction* t = calloc(1, sizeof(*t));
if (!t)
return ENOMEM;
#include <pakfire/pakfire.h>
#include <pakfire/problem.h>
#include <pakfire/request.h>
-#include <pakfire/types.h>
#include <pakfire/ui.h>
-int pakfire_ui_confirm(Pakfire pakfire, const char* message, const char* question) {
+int pakfire_ui_confirm(struct pakfire* pakfire, const char* message, const char* question) {
// The message is only printed once
printf("%s\n", message);
return r;
}
-static int pakfire_ui_enter_number(Pakfire pakfire, const char* question,
+static int pakfire_ui_enter_number(struct pakfire* pakfire, const char* question,
unsigned int* choice, unsigned int min, unsigned int max) {
// Skip this, if running in non-interactive mode
if (pakfire_has_flag(pakfire, PAKFIRE_FLAGS_NON_INTERACTIVE))
return list;
}
-int pakfire_ui_pick_solution(Pakfire pakfire, struct pakfire_request* request,
+int pakfire_ui_pick_solution(struct pakfire* pakfire, struct pakfire_request* request,
struct pakfire_problem** problems) {
if (!problems) {
errno = EINVAL;
#include <pakfire/constants.h>
#include <pakfire/logging.h>
#include <pakfire/package.h>
-#include <pakfire/types.h>
#include <pakfire/util.h>
#define NSEC_PER_SEC 1000000000
return pool_rel2id(pool, namespace, id, REL_NAMESPACE, 1);
}
-Id pakfire_parse_dep(Pakfire pakfire, const char* s) {
+Id pakfire_parse_dep(struct pakfire* pakfire, const char* s) {
Id id;
if (!s) {
return id;
}
-void pakfire_parse_deps(Pakfire pakfire, struct pakfire_package* pkg,
+void pakfire_parse_deps(struct pakfire* pakfire, struct pakfire_package* pkg,
void (*func)(struct pakfire_package* pkg, const char* dep), const char* deps) {
char* p = strdupa(deps);
}
}
-int pakfire_archive_copy_data_to_buffer(Pakfire pakfire, struct archive* a,
+int pakfire_archive_copy_data_to_buffer(struct pakfire* pakfire, struct archive* a,
struct archive_entry* entry, char** data, size_t* data_size) {
*data = NULL;
*data_size = 0;
// JSON Stuff
-static struct json_object* pakfire_json_parse(Pakfire pakfire, FILE* f) {
+static struct json_object* pakfire_json_parse(struct pakfire* pakfire, FILE* f) {
struct json_tokener* tokener = NULL;
struct json_object* json = NULL;
char* buffer = NULL;
return json;
}
-struct json_object* pakfire_json_parse_from_file(Pakfire pakfire, const char* path) {
+struct json_object* pakfire_json_parse_from_file(struct pakfire* pakfire, const char* path) {
FILE* f = fopen(path, "r");
if (!f)
return NULL;
// Resource Limits
-int pakfire_rlimit_set(Pakfire pakfire, int limit) {
+int pakfire_rlimit_set(struct pakfire* pakfire, int limit) {
struct rlimit rl;
// Sanity check
Resets RLIMIT_NOFILE to FD_SETSIZE (e.g. 1024)
for compatibility with software that uses select()
*/
-int pakfire_rlimit_reset_nofile(Pakfire pakfire) {
+int pakfire_rlimit_reset_nofile(struct pakfire* pakfire) {
return pakfire_rlimit_set(pakfire, FD_SETSIZE);
}
projects / people / ms / pakfire.git / commitdiff
