Send patches - preferably formatted by git format-patch - to patches at archlinux32 dot org.
summaryrefslogtreecommitdiff
path: root/lib/libalpm/db.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/libalpm/db.c')
-rw-r--r--lib/libalpm/db.c560
1 files changed, 281 insertions, 279 deletions
diff --git a/lib/libalpm/db.c b/lib/libalpm/db.c
index 1a3168b4..9e8e75bf 100644
--- a/lib/libalpm/db.c
+++ b/lib/libalpm/db.c
@@ -26,11 +26,8 @@
#include <stdio.h>
#include <stdlib.h>
-#include <errno.h>
#include <string.h>
-#include <sys/stat.h>
#include <regex.h>
-#include <time.h>
/* libalpm */
#include "db.h"
@@ -48,42 +45,40 @@
*/
/** Register a sync database of packages. */
-pmdb_t SYMEXPORT *alpm_db_register_sync(const char *treename)
+alpm_db_t SYMEXPORT *alpm_db_register_sync(alpm_handle_t *handle,
+ const char *treename, alpm_siglevel_t level)
{
- ALPM_LOG_FUNC;
-
/* Sanity checks */
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, NULL));
- ASSERT(treename != NULL && strlen(treename) != 0, RET_ERR(PM_ERR_WRONG_ARGS, NULL));
+ CHECK_HANDLE(handle, return NULL);
+ ASSERT(treename != NULL && strlen(treename) != 0,
+ RET_ERR(handle, ALPM_ERR_WRONG_ARGS, NULL));
/* Do not register a database if a transaction is on-going */
- ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, NULL));
+ ASSERT(handle->trans == NULL, RET_ERR(handle, ALPM_ERR_TRANS_NOT_NULL, NULL));
- return(_alpm_db_register_sync(treename));
+ return _alpm_db_register_sync(handle, treename, level);
}
/* Helper function for alpm_db_unregister{_all} */
-void _alpm_db_unregister(pmdb_t *db)
+void _alpm_db_unregister(alpm_db_t *db)
{
if(db == NULL) {
return;
}
- _alpm_log(PM_LOG_DEBUG, "unregistering database '%s'\n", db->treename);
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "unregistering database '%s'\n", db->treename);
_alpm_db_free(db);
}
/** Unregister all package databases. */
-int SYMEXPORT alpm_db_unregister_all(void)
+int SYMEXPORT alpm_db_unregister_all(alpm_handle_t *handle)
{
alpm_list_t *i;
- pmdb_t *db;
-
- ALPM_LOG_FUNC;
+ alpm_db_t *db;
/* Sanity checks */
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
/* Do not unregister a database if a transaction is on-going */
- ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, -1));
+ ASSERT(handle->trans == NULL, RET_ERR(handle, ALPM_ERR_TRANS_NOT_NULL, -1));
/* unregister all sync dbs */
for(i = handle->dbs_sync; i; i = i->next) {
@@ -92,21 +87,21 @@ int SYMEXPORT alpm_db_unregister_all(void)
i->data = NULL;
}
FREELIST(handle->dbs_sync);
- return(0);
+ return 0;
}
/** Unregister a package database. */
-int SYMEXPORT alpm_db_unregister(pmdb_t *db)
+int SYMEXPORT alpm_db_unregister(alpm_db_t *db)
{
int found = 0;
-
- ALPM_LOG_FUNC;
+ alpm_handle_t *handle;
/* Sanity checks */
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
- ASSERT(db != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
+ ASSERT(db != NULL, return -1);
/* Do not unregister a database if a transaction is on-going */
- ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, -1));
+ handle = db->handle;
+ handle->pm_errno = 0;
+ ASSERT(handle->trans == NULL, RET_ERR(handle, ALPM_ERR_TRANS_NOT_NULL, -1));
if(db == handle->db_local) {
handle->db_local = NULL;
@@ -125,196 +120,219 @@ int SYMEXPORT alpm_db_unregister(pmdb_t *db)
}
if(!found) {
- RET_ERR(PM_ERR_DB_NOT_FOUND, -1);
+ RET_ERR(handle, ALPM_ERR_DB_NOT_FOUND, -1);
}
db->ops->unregister(db);
- return(0);
+ return 0;
+}
+
+/** Get the serverlist of a database. */
+alpm_list_t SYMEXPORT *alpm_db_get_servers(const alpm_db_t *db)
+{
+ ASSERT(db != NULL, return NULL);
+ return db->servers;
}
/** Set the serverlist of a database. */
-int SYMEXPORT alpm_db_setserver(pmdb_t *db, const char *url)
+int SYMEXPORT alpm_db_set_servers(alpm_db_t *db, alpm_list_t *servers)
+{
+ ASSERT(db != NULL, return -1);
+ if(db->servers) FREELIST(db->servers);
+ db->servers = servers;
+ return 0;
+}
+
+static char *sanitize_url(const char *url)
{
- alpm_list_t *i;
- int found = 0;
char *newurl;
- size_t len = 0;
+ size_t len = strlen(url);
+
+ STRDUP(newurl, url, return NULL);
+ /* strip the trailing slash if one exists */
+ if(newurl[len - 1] == '/') {
+ newurl[len - 1] = '\0';
+ }
+ return newurl;
+}
- ALPM_LOG_FUNC;
+/** Add a download server to a database.
+ * @param db database pointer
+ * @param url url of the server
+ * @return 0 on success, -1 on error (pm_errno is set accordingly)
+ */
+int SYMEXPORT alpm_db_add_server(alpm_db_t *db, const char *url)
+{
+ char *newurl;
/* Sanity checks */
- ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
+ ASSERT(db != NULL, return -1);
+ db->handle->pm_errno = 0;
+ ASSERT(url != NULL && strlen(url) != 0, RET_ERR(db->handle, ALPM_ERR_WRONG_ARGS, -1));
- for(i = handle->dbs_sync; i && !found; i = i->next) {
- pmdb_t *sdb = i->data;
- if(strcmp(db->treename, sdb->treename) == 0) {
- found = 1;
- }
- }
- if(!found) {
- RET_ERR(PM_ERR_DB_NOT_FOUND, -1);
+ newurl = sanitize_url(url);
+ if(!newurl) {
+ return -1;
}
+ db->servers = alpm_list_add(db->servers, newurl);
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "adding new server URL to database '%s': %s\n",
+ db->treename, newurl);
- if(url) {
- len = strlen(url);
- }
- if(len) {
- newurl = strdup(url);
- /* strip the trailing slash if one exists */
- if(newurl[len - 1] == '/') {
- newurl[len - 1] = '\0';
- }
- db->servers = alpm_list_add(db->servers, newurl);
- _alpm_log(PM_LOG_DEBUG, "adding new server URL to database '%s': %s\n",
+ return 0;
+}
+
+/** Remove a download server from a database.
+ * @param db database pointer
+ * @param url url of the server
+ * @return 0 on success, 1 on server not present,
+ * -1 on error (pm_errno is set accordingly)
+ */
+int SYMEXPORT alpm_db_remove_server(alpm_db_t *db, const char *url)
+{
+ char *newurl, *vdata = NULL;
+
+ /* Sanity checks */
+ ASSERT(db != NULL, return -1);
+ db->handle->pm_errno = 0;
+ ASSERT(url != NULL && strlen(url) != 0, RET_ERR(db->handle, ALPM_ERR_WRONG_ARGS, -1));
+
+ newurl = sanitize_url(url);
+ if(!newurl) {
+ return -1;
+ }
+ db->servers = alpm_list_remove_str(db->servers, newurl, &vdata);
+ free(newurl);
+ if(vdata) {
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "removed server URL from database '%s': %s\n",
db->treename, newurl);
- } else {
- FREELIST(db->servers);
- _alpm_log(PM_LOG_DEBUG, "serverlist flushed for '%s'\n", db->treename);
+ free(vdata);
+ return 0;
}
- return(0);
+ return 1;
}
/** Get the name of a package database. */
-const char SYMEXPORT *alpm_db_get_name(const pmdb_t *db)
+const char SYMEXPORT *alpm_db_get_name(const alpm_db_t *db)
{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
-
+ ASSERT(db != NULL, return NULL);
return db->treename;
}
-/** Get a download URL for the package database. */
-const char SYMEXPORT *alpm_db_get_url(const pmdb_t *db)
+/** Get the signature verification level for a database. */
+alpm_siglevel_t SYMEXPORT alpm_db_get_siglevel(alpm_db_t *db)
{
- char *url;
-
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
- ASSERT(db->servers != NULL, return(NULL));
-
- url = (char*)db->servers->data;
-
- return(url);
+ ASSERT(db != NULL, return -1);
+ if(db->siglevel & ALPM_SIG_USE_DEFAULT) {
+ return alpm_option_get_default_siglevel(db->handle);
+ } else {
+ return db->siglevel;
+ }
}
+/** Check the validity of a database. */
+int SYMEXPORT alpm_db_get_valid(alpm_db_t *db)
+{
+ ASSERT(db != NULL, return -1);
+ db->handle->pm_errno = 0;
+ return db->ops->validate(db);
+}
/** Get a package entry from a package database. */
-pmpkg_t SYMEXPORT *alpm_db_get_pkg(pmdb_t *db, const char *name)
+alpm_pkg_t SYMEXPORT *alpm_db_get_pkg(alpm_db_t *db, const char *name)
{
- ALPM_LOG_FUNC;
+ alpm_pkg_t *pkg;
+ ASSERT(db != NULL, return NULL);
+ db->handle->pm_errno = 0;
+ ASSERT(name != NULL && strlen(name) != 0,
+ RET_ERR(db->handle, ALPM_ERR_WRONG_ARGS, NULL));
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
- ASSERT(name != NULL && strlen(name) != 0, return(NULL));
-
- return(_alpm_db_get_pkgfromcache(db, name));
+ pkg = _alpm_db_get_pkgfromcache(db, name);
+ if(!pkg) {
+ RET_ERR(db->handle, ALPM_ERR_PKG_NOT_FOUND, NULL);
+ }
+ return pkg;
}
/** Get the package cache of a package database. */
-alpm_list_t SYMEXPORT *alpm_db_get_pkgcache(pmdb_t *db)
+alpm_list_t SYMEXPORT *alpm_db_get_pkgcache(alpm_db_t *db)
{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
-
- return(_alpm_db_get_pkgcache(db));
+ ASSERT(db != NULL, return NULL);
+ db->handle->pm_errno = 0;
+ return _alpm_db_get_pkgcache(db);
}
/** Get a group entry from a package database. */
-pmgrp_t SYMEXPORT *alpm_db_readgrp(pmdb_t *db, const char *name)
+alpm_group_t SYMEXPORT *alpm_db_readgroup(alpm_db_t *db, const char *name)
{
- ALPM_LOG_FUNC;
+ ASSERT(db != NULL, return NULL);
+ db->handle->pm_errno = 0;
+ ASSERT(name != NULL && strlen(name) != 0,
+ RET_ERR(db->handle, ALPM_ERR_WRONG_ARGS, NULL));
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
- ASSERT(name != NULL && strlen(name) != 0, return(NULL));
-
- return(_alpm_db_get_grpfromcache(db, name));
+ return _alpm_db_get_groupfromcache(db, name);
}
/** Get the group cache of a package database. */
-alpm_list_t SYMEXPORT *alpm_db_get_grpcache(pmdb_t *db)
+alpm_list_t SYMEXPORT *alpm_db_get_groupcache(alpm_db_t *db)
{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
+ ASSERT(db != NULL, return NULL);
+ db->handle->pm_errno = 0;
- return(_alpm_db_get_grpcache(db));
+ return _alpm_db_get_groupcache(db);
}
/** Searches a database. */
-alpm_list_t SYMEXPORT *alpm_db_search(pmdb_t *db, const alpm_list_t* needles)
+alpm_list_t SYMEXPORT *alpm_db_search(alpm_db_t *db, const alpm_list_t* needles)
{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
+ ASSERT(db != NULL, return NULL);
+ db->handle->pm_errno = 0;
- return(_alpm_db_search(db, needles));
+ return _alpm_db_search(db, needles);
}
/** Set install reason for a package in db. */
-int SYMEXPORT alpm_db_set_pkgreason(pmdb_t *db, const char *name, pmpkgreason_t reason)
+int SYMEXPORT alpm_db_set_pkgreason(alpm_handle_t *handle, alpm_pkg_t *pkg,
+ alpm_pkgreason_t reason)
{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
- ASSERT(db != NULL && name != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
-
- pmpkg_t *pkg = _alpm_db_get_pkgfromcache(db, name);
- if(pkg == NULL) {
- RET_ERR(PM_ERR_PKG_NOT_FOUND, -1);
- }
-
- _alpm_log(PM_LOG_DEBUG, "setting install reason %u for %s/%s\n", reason, db->treename, name);
+ CHECK_HANDLE(handle, return -1);
+ ASSERT(pkg != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
+ ASSERT(pkg->origin == PKG_FROM_LOCALDB,
+ RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
+ ASSERT(pkg->origin_data.db == handle->db_local,
+ RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
+
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "setting install reason %u for %s\n", reason, pkg->name);
if(alpm_pkg_get_reason(pkg) == reason) {
/* we are done */
- return(0);
+ return 0;
}
/* set reason (in pkgcache) */
pkg->reason = reason;
/* write DESC */
- if(_alpm_local_db_write(db, pkg, INFRQ_DESC)) {
- RET_ERR(PM_ERR_DB_WRITE, -1);
+ if(_alpm_local_db_write(handle->db_local, pkg, INFRQ_DESC)) {
+ RET_ERR(handle, ALPM_ERR_DB_WRITE, -1);
}
- return(0);
+ return 0;
}
/** @} */
-pmdb_t *_alpm_db_new(const char *treename, int is_local)
+alpm_db_t *_alpm_db_new(const char *treename, int is_local)
{
- pmdb_t *db;
-
- ALPM_LOG_FUNC;
+ alpm_db_t *db;
- CALLOC(db, 1, sizeof(pmdb_t), RET_ERR(PM_ERR_MEMORY, NULL));
- STRDUP(db->treename, treename, RET_ERR(PM_ERR_MEMORY, NULL));
+ CALLOC(db, 1, sizeof(alpm_db_t), return NULL);
+ STRDUP(db->treename, treename, return NULL);
db->is_local = is_local;
- return(db);
+ return db;
}
-void _alpm_db_free(pmdb_t *db)
+void _alpm_db_free(alpm_db_t *db)
{
- ALPM_LOG_FUNC;
-
/* cleanup pkgcache */
_alpm_db_free_pkgcache(db);
/* cleanup server list */
@@ -326,61 +344,65 @@ void _alpm_db_free(pmdb_t *db)
return;
}
-const char *_alpm_db_path(pmdb_t *db)
+const char *_alpm_db_path(alpm_db_t *db)
{
if(!db) {
- return(NULL);
+ return NULL;
}
if(!db->_path) {
const char *dbpath;
size_t pathsize;
- dbpath = alpm_option_get_dbpath();
+ dbpath = alpm_option_get_dbpath(db->handle);
if(!dbpath) {
- _alpm_log(PM_LOG_ERROR, _("database path is undefined\n"));
- RET_ERR(PM_ERR_DB_OPEN, NULL);
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("database path is undefined\n"));
+ RET_ERR(db->handle, ALPM_ERR_DB_OPEN, NULL);
}
if(db->is_local) {
pathsize = strlen(dbpath) + strlen(db->treename) + 2;
- CALLOC(db->_path, 1, pathsize, RET_ERR(PM_ERR_MEMORY, NULL));
+ CALLOC(db->_path, 1, pathsize, RET_ERR(db->handle, ALPM_ERR_MEMORY, NULL));
sprintf(db->_path, "%s%s/", dbpath, db->treename);
} else {
pathsize = strlen(dbpath) + 5 + strlen(db->treename) + 4;
- CALLOC(db->_path, 1, pathsize, RET_ERR(PM_ERR_MEMORY, NULL));
+ CALLOC(db->_path, 1, pathsize, RET_ERR(db->handle, ALPM_ERR_MEMORY, NULL));
/* all sync DBs now reside in the sync/ subdir of the dbpath */
sprintf(db->_path, "%ssync/%s.db", dbpath, db->treename);
}
- _alpm_log(PM_LOG_DEBUG, "database path for tree %s set to %s\n",
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "database path for tree %s set to %s\n",
db->treename, db->_path);
}
- return(db->_path);
+ return db->_path;
}
-int _alpm_db_version(pmdb_t *db)
+char *_alpm_db_sig_path(alpm_db_t *db)
{
- if(!db) {
- return(-1);
- }
- return(db->ops->version(db));
+ char *sigpath;
+ size_t len;
+ const char *dbfile = _alpm_db_path(db);
+ if(!db || !dbfile) {
+ return NULL;
+ }
+ len = strlen(dbfile) + strlen(".sig") + 1;
+ CALLOC(sigpath, len, sizeof(char), RET_ERR(db->handle, ALPM_ERR_MEMORY, NULL));
+ sprintf(sigpath, "%s.sig", dbfile);
+ return sigpath;
}
int _alpm_db_cmp(const void *d1, const void *d2)
{
- pmdb_t *db1 = (pmdb_t *)d1;
- pmdb_t *db2 = (pmdb_t *)d2;
- return(strcmp(db1->treename, db2->treename));
+ alpm_db_t *db1 = (alpm_db_t *)d1;
+ alpm_db_t *db2 = (alpm_db_t *)d2;
+ return strcmp(db1->treename, db2->treename);
}
-alpm_list_t *_alpm_db_search(pmdb_t *db, const alpm_list_t *needles)
+alpm_list_t *_alpm_db_search(alpm_db_t *db, const alpm_list_t *needles)
{
const alpm_list_t *i, *j, *k;
alpm_list_t *ret = NULL;
/* copy the pkgcache- we will free the list var after each needle */
alpm_list_t *list = alpm_list_copy(_alpm_db_get_pkgcache(db));
- ALPM_LOG_FUNC;
-
for(i = needles; i; i = i->next) {
char *targ;
regex_t reg;
@@ -390,14 +412,14 @@ alpm_list_t *_alpm_db_search(pmdb_t *db, const alpm_list_t *needles)
}
ret = NULL;
targ = i->data;
- _alpm_log(PM_LOG_DEBUG, "searching for target '%s'\n", targ);
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "searching for target '%s'\n", targ);
if(regcomp(&reg, targ, REG_EXTENDED | REG_NOSUB | REG_ICASE | REG_NEWLINE) != 0) {
- RET_ERR(PM_ERR_INVALID_REGEX, NULL);
+ RET_ERR(db->handle, ALPM_ERR_INVALID_REGEX, NULL);
}
for(j = list; j; j = j->next) {
- pmpkg_t *pkg = j->data;
+ alpm_pkg_t *pkg = j->data;
const char *matched = NULL;
const char *name = alpm_pkg_get_name(pkg);
const char *desc = alpm_pkg_get_desc(pkg);
@@ -407,7 +429,7 @@ alpm_list_t *_alpm_db_search(pmdb_t *db, const alpm_list_t *needles)
matched = name;
}
/* check desc */
- else if (desc && regexec(&reg, desc, 0, 0, 0) == 0) {
+ else if(desc && regexec(&reg, desc, 0, 0, 0) == 0) {
matched = desc;
}
/* TODO: should we be doing this, and should we print something
@@ -415,7 +437,7 @@ alpm_list_t *_alpm_db_search(pmdb_t *db, const alpm_list_t *needles)
if(!matched) {
/* check provides */
for(k = alpm_pkg_get_provides(pkg); k; k = k->next) {
- if (regexec(&reg, k->data, 0, 0, 0) == 0) {
+ if(regexec(&reg, k->data, 0, 0, 0) == 0) {
matched = k->data;
break;
}
@@ -424,7 +446,7 @@ alpm_list_t *_alpm_db_search(pmdb_t *db, const alpm_list_t *needles)
if(!matched) {
/* check groups */
for(k = alpm_pkg_get_groups(pkg); k; k = k->next) {
- if (regexec(&reg, k->data, 0, 0, 0) == 0) {
+ if(regexec(&reg, k->data, 0, 0, 0) == 0) {
matched = k->data;
break;
}
@@ -432,7 +454,7 @@ alpm_list_t *_alpm_db_search(pmdb_t *db, const alpm_list_t *needles)
}
if(matched != NULL) {
- _alpm_log(PM_LOG_DEBUG, " search target '%s' matched '%s'\n",
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, " search target '%s' matched '%s'\n",
targ, matched);
ret = alpm_list_add(ret, pkg);
}
@@ -445,179 +467,176 @@ alpm_list_t *_alpm_db_search(pmdb_t *db, const alpm_list_t *needles)
regfree(&reg);
}
- return(ret);
+ return ret;
}
/* Returns a new package cache from db.
* It frees the cache if it already exists.
*/
-int _alpm_db_load_pkgcache(pmdb_t *db)
+static int load_pkgcache(alpm_db_t *db)
{
- ALPM_LOG_FUNC;
-
- if(db == NULL) {
- return(-1);
- }
_alpm_db_free_pkgcache(db);
- _alpm_log(PM_LOG_DEBUG, "loading package cache for repository '%s'\n",
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "loading package cache for repository '%s'\n",
db->treename);
if(db->ops->populate(db) == -1) {
- _alpm_log(PM_LOG_DEBUG,
+ _alpm_log(db->handle, ALPM_LOG_DEBUG,
"failed to load package cache for repository '%s'\n", db->treename);
- return(-1);
+ return -1;
}
- db->pkgcache_loaded = 1;
- return(0);
+ db->status |= DB_STATUS_PKGCACHE;
+ return 0;
}
-void _alpm_db_free_pkgcache(pmdb_t *db)
+static void free_groupcache(alpm_db_t *db)
{
- ALPM_LOG_FUNC;
+ alpm_list_t *lg;
- if(db == NULL || !db->pkgcache_loaded) {
+ if(db == NULL || !(db->status & DB_STATUS_GRPCACHE)) {
return;
}
- _alpm_log(PM_LOG_DEBUG, "freeing package cache for repository '%s'\n",
- db->treename);
+ _alpm_log(db->handle, ALPM_LOG_DEBUG,
+ "freeing group cache for repository '%s'\n", db->treename);
+
+ for(lg = db->grpcache; lg; lg = lg->next) {
+ _alpm_group_free(lg->data);
+ lg->data = NULL;
+ }
+ FREELIST(db->grpcache);
+ db->status &= ~DB_STATUS_GRPCACHE;
+}
+
+void _alpm_db_free_pkgcache(alpm_db_t *db)
+{
+ if(db == NULL || !(db->status & DB_STATUS_PKGCACHE)) {
+ return;
+ }
+
+ _alpm_log(db->handle, ALPM_LOG_DEBUG,
+ "freeing package cache for repository '%s'\n", db->treename);
alpm_list_free_inner(_alpm_db_get_pkgcache(db),
(alpm_list_fn_free)_alpm_pkg_free);
_alpm_pkghash_free(db->pkgcache);
- db->pkgcache_loaded = 0;
+ db->status &= ~DB_STATUS_PKGCACHE;
- _alpm_db_free_grpcache(db);
+ free_groupcache(db);
}
-pmpkghash_t *_alpm_db_get_pkgcache_hash(pmdb_t *db)
+alpm_pkghash_t *_alpm_db_get_pkgcache_hash(alpm_db_t *db)
{
- ALPM_LOG_FUNC;
-
if(db == NULL) {
- return(NULL);
+ return NULL;
}
- if(!db->pkgcache_loaded) {
- _alpm_db_load_pkgcache(db);
+ if(!(db->status & DB_STATUS_VALID)) {
+ RET_ERR(db->handle, ALPM_ERR_DB_INVALID, NULL);
}
- /* hmmm, still NULL ?*/
- if(!db->pkgcache) {
- _alpm_log(PM_LOG_DEBUG, "warning: pkgcache is NULL for db '%s'\n", db->treename);
+ if(!(db->status & DB_STATUS_PKGCACHE)) {
+ load_pkgcache(db);
}
- return(db->pkgcache);
+ return db->pkgcache;
}
-alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db)
+alpm_list_t *_alpm_db_get_pkgcache(alpm_db_t *db)
{
- ALPM_LOG_FUNC;
-
- pmpkghash_t *hash = _alpm_db_get_pkgcache_hash(db);
+ alpm_pkghash_t *hash = _alpm_db_get_pkgcache_hash(db);
if(hash == NULL) {
- return(NULL);
+ return NULL;
}
- return(hash->list);
+ return hash->list;
}
/* "duplicate" pkg then add it to pkgcache */
-int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg)
+int _alpm_db_add_pkgincache(alpm_db_t *db, alpm_pkg_t *pkg)
{
- pmpkg_t *newpkg;
+ alpm_pkg_t *newpkg;
- ALPM_LOG_FUNC;
-
- if(db == NULL || !db->pkgcache_loaded || pkg == NULL) {
- return(-1);
+ if(db == NULL || pkg == NULL || !(db->status & DB_STATUS_PKGCACHE)) {
+ return -1;
}
newpkg = _alpm_pkg_dup(pkg);
if(newpkg == NULL) {
- return(-1);
+ return -1;
}
- _alpm_log(PM_LOG_DEBUG, "adding entry '%s' in '%s' cache\n",
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "adding entry '%s' in '%s' cache\n",
alpm_pkg_get_name(newpkg), db->treename);
db->pkgcache = _alpm_pkghash_add_sorted(db->pkgcache, newpkg);
- _alpm_db_free_grpcache(db);
+ free_groupcache(db);
- return(0);
+ return 0;
}
-int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg)
+int _alpm_db_remove_pkgfromcache(alpm_db_t *db, alpm_pkg_t *pkg)
{
- pmpkg_t *data = NULL;
-
- ALPM_LOG_FUNC;
+ alpm_pkg_t *data = NULL;
- if(db == NULL || !db->pkgcache_loaded || pkg == NULL) {
- return(-1);
+ if(db == NULL || pkg == NULL || !(db->status & DB_STATUS_PKGCACHE)) {
+ return -1;
}
- _alpm_log(PM_LOG_DEBUG, "removing entry '%s' from '%s' cache\n",
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "removing entry '%s' from '%s' cache\n",
alpm_pkg_get_name(pkg), db->treename);
db->pkgcache = _alpm_pkghash_remove(db->pkgcache, pkg, &data);
if(data == NULL) {
/* package not found */
- _alpm_log(PM_LOG_DEBUG, "cannot remove entry '%s' from '%s' cache: not found\n",
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "cannot remove entry '%s' from '%s' cache: not found\n",
alpm_pkg_get_name(pkg), db->treename);
- return(-1);
+ return -1;
}
_alpm_pkg_free(data);
- _alpm_db_free_grpcache(db);
+ free_groupcache(db);
- return(0);
+ return 0;
}
-pmpkg_t *_alpm_db_get_pkgfromcache(pmdb_t *db, const char *target)
+alpm_pkg_t *_alpm_db_get_pkgfromcache(alpm_db_t *db, const char *target)
{
- ALPM_LOG_FUNC;
-
if(db == NULL) {
- return(NULL);
+ return NULL;
}
- pmpkghash_t *pkgcache = _alpm_db_get_pkgcache_hash(db);
+ alpm_pkghash_t *pkgcache = _alpm_db_get_pkgcache_hash(db);
if(!pkgcache) {
- _alpm_log(PM_LOG_DEBUG, "warning: failed to get '%s' from NULL pkgcache\n",
- target);
- return(NULL);
+ return NULL;
}
- return(_alpm_pkghash_find(pkgcache, target));
+ return _alpm_pkghash_find(pkgcache, target);
}
/* Returns a new group cache from db.
*/
-int _alpm_db_load_grpcache(pmdb_t *db)
+static int load_grpcache(alpm_db_t *db)
{
alpm_list_t *lp;
- ALPM_LOG_FUNC;
-
if(db == NULL) {
- return(-1);
+ return -1;
}
- _alpm_log(PM_LOG_DEBUG, "loading group cache for repository '%s'\n",
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "loading group cache for repository '%s'\n",
db->treename);
for(lp = _alpm_db_get_pkgcache(db); lp; lp = lp->next) {
const alpm_list_t *i;
- pmpkg_t *pkg = lp->data;
+ alpm_pkg_t *pkg = lp->data;
for(i = alpm_pkg_get_groups(pkg); i; i = i->next) {
const char *grpname = i->data;
alpm_list_t *j;
- pmgrp_t *grp = NULL;
+ alpm_group_t *grp = NULL;
int found = 0;
/* first look through the group cache for a group with this name */
@@ -635,71 +654,54 @@ int _alpm_db_load_grpcache(pmdb_t *db)
continue;
}
/* we didn't find the group, so create a new one with this name */
- grp = _alpm_grp_new(grpname);
+ grp = _alpm_group_new(grpname);
+ if(!grp) {
+ free_groupcache(db);
+ return -1;
+ }
grp->packages = alpm_list_add(grp->packages, pkg);
db->grpcache = alpm_list_add(db->grpcache, grp);
}
}
- db->grpcache_loaded = 1;
- return(0);
+ db->status |= DB_STATUS_GRPCACHE;
+ return 0;
}
-void _alpm_db_free_grpcache(pmdb_t *db)
+alpm_list_t *_alpm_db_get_groupcache(alpm_db_t *db)
{
- alpm_list_t *lg;
-
- ALPM_LOG_FUNC;
-
- if(db == NULL || !db->grpcache_loaded) {
- return;
- }
-
- _alpm_log(PM_LOG_DEBUG, "freeing group cache for repository '%s'\n",
- db->treename);
-
- for(lg = db->grpcache; lg; lg = lg->next) {
- _alpm_grp_free(lg->data);
- lg->data = NULL;
+ if(db == NULL) {
+ return NULL;
}
- FREELIST(db->grpcache);
- db->grpcache_loaded = 0;
-}
-
-alpm_list_t *_alpm_db_get_grpcache(pmdb_t *db)
-{
- ALPM_LOG_FUNC;
- if(db == NULL) {
- return(NULL);
+ if(!(db->status & DB_STATUS_VALID)) {
+ RET_ERR(db->handle, ALPM_ERR_DB_INVALID, NULL);
}
- if(!db->grpcache_loaded) {
- _alpm_db_load_grpcache(db);
+ if(!(db->status & DB_STATUS_GRPCACHE)) {
+ load_grpcache(db);
}
- return(db->grpcache);
+ return db->grpcache;
}
-pmgrp_t *_alpm_db_get_grpfromcache(pmdb_t *db, const char *target)
+alpm_group_t *_alpm_db_get_groupfromcache(alpm_db_t *db, const char *target)
{
alpm_list_t *i;
- ALPM_LOG_FUNC;
-
if(db == NULL || target == NULL || strlen(target) == 0) {
- return(NULL);
+ return NULL;
}
- for(i = _alpm_db_get_grpcache(db); i; i = i->next) {
- pmgrp_t *info = i->data;
+ for(i = _alpm_db_get_groupcache(db); i; i = i->next) {
+ alpm_group_t *info = i->data;
if(strcmp(info->name, target) == 0) {
- return(info);
+ return info;
}
}
- return(NULL);
+ return NULL;
}
/* vim: set ts=2 sw=2 noet: */

Copyright © 2002-2022 Judd Vinet and Aaron Griffin. Copyright © 2022 Erich Eckner.
The Arch Linux name and logo are recognized trademarks. Some rights reserved. The registered trademark Linux® is used pursuant to a sublicense from LMI, the exclusive licensee of Linus Torvalds, owner of the mark on a world-wide basis.