mirror of
https://github.com/moparisthebest/pacman
synced 2024-12-23 16:28:50 -05:00
a36ff9404b
Signed-off-by: Dan McGee <dan@archlinux.org>
517 lines
13 KiB
C
517 lines
13 KiB
C
/*
|
|
* db.c
|
|
*
|
|
* Copyright (c) 2006-2010 Pacman Development Team <pacman-dev@archlinux.org>
|
|
* Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
|
|
* Copyright (c) 2005 by Aurelien Foret <orelien@chez.com>
|
|
* Copyright (c) 2005 by Christian Hamar <krics@linuxforum.hu>
|
|
* Copyright (c) 2006 by David Kimpe <dnaku@frugalware.org>
|
|
* Copyright (c) 2005, 2006 by Miklos Vajna <vmiklos@frugalware.org>
|
|
*
|
|
* 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 2 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/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <dirent.h>
|
|
#include <regex.h>
|
|
#include <time.h>
|
|
|
|
/* libalpm */
|
|
#include "db.h"
|
|
#include "alpm_list.h"
|
|
#include "log.h"
|
|
#include "util.h"
|
|
#include "handle.h"
|
|
#include "cache.h"
|
|
#include "alpm.h"
|
|
|
|
/** \addtogroup alpm_databases Database Functions
|
|
* @brief Functions to query and manipulate the database of libalpm
|
|
* @{
|
|
*/
|
|
|
|
/** Register a sync database of packages.
|
|
* @param treename the name of the sync repository
|
|
* @return a pmdb_t* on success (the value), NULL on error
|
|
*/
|
|
pmdb_t SYMEXPORT *alpm_db_register_sync(const char *treename)
|
|
{
|
|
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));
|
|
/* Do not register a database if a transaction is on-going */
|
|
ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, NULL));
|
|
|
|
return(_alpm_db_register_sync(treename));
|
|
}
|
|
|
|
/** Register the local package database.
|
|
* @return a pmdb_t* representing the local database, or NULL on error
|
|
*/
|
|
pmdb_t SYMEXPORT *alpm_db_register_local(void)
|
|
{
|
|
ALPM_LOG_FUNC;
|
|
|
|
/* Sanity checks */
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, NULL));
|
|
/* Do not register a database if a transaction is on-going */
|
|
ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, NULL));
|
|
|
|
return(_alpm_db_register_local());
|
|
}
|
|
|
|
/* Helper function for alpm_db_unregister{_all} */
|
|
static void _alpm_db_unregister(pmdb_t *db)
|
|
{
|
|
if(db == NULL) {
|
|
return;
|
|
}
|
|
|
|
_alpm_log(PM_LOG_DEBUG, "unregistering database '%s'\n", db->treename);
|
|
_alpm_db_free(db);
|
|
}
|
|
|
|
/** Unregister all package databases
|
|
* @return 0 on success, -1 on error (pm_errno is set accordingly)
|
|
*/
|
|
int SYMEXPORT alpm_db_unregister_all(void)
|
|
{
|
|
alpm_list_t *i;
|
|
|
|
ALPM_LOG_FUNC;
|
|
|
|
/* Sanity checks */
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
|
/* Do not unregister a database if a transaction is on-going */
|
|
ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, -1));
|
|
|
|
/* close local database */
|
|
_alpm_db_unregister(handle->db_local);
|
|
handle->db_local = NULL;
|
|
|
|
/* and also sync ones */
|
|
for(i = handle->dbs_sync; i; i = i->next) {
|
|
pmdb_t *db = i->data;
|
|
_alpm_db_unregister(db);
|
|
i->data = NULL;
|
|
}
|
|
FREELIST(handle->dbs_sync);
|
|
return(0);
|
|
}
|
|
|
|
/** Unregister a package database
|
|
* @param db pointer to the package database to unregister
|
|
* @return 0 on success, -1 on error (pm_errno is set accordingly)
|
|
*/
|
|
int SYMEXPORT alpm_db_unregister(pmdb_t *db)
|
|
{
|
|
int found = 0;
|
|
|
|
ALPM_LOG_FUNC;
|
|
|
|
/* Sanity checks */
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
|
ASSERT(db != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
|
|
/* Do not unregister a database if a transaction is on-going */
|
|
ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, -1));
|
|
|
|
if(db == handle->db_local) {
|
|
handle->db_local = NULL;
|
|
found = 1;
|
|
} else {
|
|
/* Warning : this function shouldn't be used to unregister all sync
|
|
* databases by walking through the list returned by
|
|
* alpm_option_get_syncdbs, because the db is removed from that list here.
|
|
*/
|
|
void *data;
|
|
handle->dbs_sync = alpm_list_remove(handle->dbs_sync,
|
|
db, _alpm_db_cmp, &data);
|
|
if(data) {
|
|
found = 1;
|
|
}
|
|
}
|
|
|
|
if(!found) {
|
|
RET_ERR(PM_ERR_DB_NOT_FOUND, -1);
|
|
}
|
|
|
|
_alpm_db_unregister(db);
|
|
return(0);
|
|
}
|
|
|
|
/** Set the serverlist of 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_setserver(pmdb_t *db, const char *url)
|
|
{
|
|
alpm_list_t *i;
|
|
int found = 0;
|
|
char *newurl;
|
|
int len = 0;
|
|
|
|
ALPM_LOG_FUNC;
|
|
|
|
/* Sanity checks */
|
|
ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -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);
|
|
}
|
|
|
|
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",
|
|
db->treename, newurl);
|
|
} else {
|
|
FREELIST(db->servers);
|
|
_alpm_log(PM_LOG_DEBUG, "serverlist flushed for '%s'\n", db->treename);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
/** Get the name of a package database
|
|
* @param db pointer to the package database
|
|
* @return the name of the package database, NULL on error
|
|
*/
|
|
const char SYMEXPORT *alpm_db_get_name(const pmdb_t *db)
|
|
{
|
|
ALPM_LOG_FUNC;
|
|
|
|
/* Sanity checks */
|
|
ASSERT(handle != NULL, return(NULL));
|
|
ASSERT(db != NULL, return(NULL));
|
|
|
|
return db->treename;
|
|
}
|
|
|
|
/** Get a download URL for the package database
|
|
* @param db pointer to the package database
|
|
* @return a fully-specified download URL, NULL on error
|
|
*/
|
|
const char SYMEXPORT *alpm_db_get_url(const pmdb_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);
|
|
}
|
|
|
|
|
|
/** Get a package entry from a package database
|
|
* @param db pointer to the package database to get the package from
|
|
* @param name of the package
|
|
* @return the package entry on success, NULL on error
|
|
*/
|
|
pmpkg_t SYMEXPORT *alpm_db_get_pkg(pmdb_t *db, const char *name)
|
|
{
|
|
ALPM_LOG_FUNC;
|
|
|
|
/* 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));
|
|
}
|
|
|
|
/** Get the package cache of a package database
|
|
* @param db pointer to the package database to get the package from
|
|
* @return the list of packages on success, NULL on error
|
|
*/
|
|
alpm_list_t SYMEXPORT *alpm_db_get_pkgcache(pmdb_t *db)
|
|
{
|
|
ALPM_LOG_FUNC;
|
|
|
|
/* Sanity checks */
|
|
ASSERT(handle != NULL, return(NULL));
|
|
ASSERT(db != NULL, return(NULL));
|
|
|
|
return(_alpm_db_get_pkgcache(db));
|
|
}
|
|
|
|
/** Get a group entry from a package database
|
|
* @param db pointer to the package database to get the group from
|
|
* @param name of the group
|
|
* @return the groups entry on success, NULL on error
|
|
*/
|
|
pmgrp_t SYMEXPORT *alpm_db_readgrp(pmdb_t *db, const char *name)
|
|
{
|
|
ALPM_LOG_FUNC;
|
|
|
|
/* 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));
|
|
}
|
|
|
|
/** Get the group cache of a package database
|
|
* @param db pointer to the package database to get the group from
|
|
* @return the list of groups on success, NULL on error
|
|
*/
|
|
alpm_list_t SYMEXPORT *alpm_db_get_grpcache(pmdb_t *db)
|
|
{
|
|
ALPM_LOG_FUNC;
|
|
|
|
/* Sanity checks */
|
|
ASSERT(handle != NULL, return(NULL));
|
|
ASSERT(db != NULL, return(NULL));
|
|
|
|
return(_alpm_db_get_grpcache(db));
|
|
}
|
|
|
|
/** Searches a database
|
|
* @param db pointer to the package database to search in
|
|
* @param needles the list of strings to search for
|
|
* @return the list of packages on success, NULL on error
|
|
*/
|
|
alpm_list_t SYMEXPORT *alpm_db_search(pmdb_t *db, const alpm_list_t* needles)
|
|
{
|
|
ALPM_LOG_FUNC;
|
|
|
|
/* Sanity checks */
|
|
ASSERT(handle != NULL, return(NULL));
|
|
ASSERT(db != NULL, return(NULL));
|
|
|
|
return(_alpm_db_search(db, needles));
|
|
}
|
|
|
|
/** @} */
|
|
|
|
static pmdb_t *_alpm_db_new(const char *treename, int is_local)
|
|
{
|
|
pmdb_t *db;
|
|
|
|
ALPM_LOG_FUNC;
|
|
|
|
CALLOC(db, 1, sizeof(pmdb_t), RET_ERR(PM_ERR_MEMORY, NULL));
|
|
STRDUP(db->treename, treename, RET_ERR(PM_ERR_MEMORY, NULL));
|
|
db->is_local = is_local;
|
|
|
|
return(db);
|
|
}
|
|
|
|
void _alpm_db_free(pmdb_t *db)
|
|
{
|
|
ALPM_LOG_FUNC;
|
|
|
|
/* cleanup pkgcache */
|
|
_alpm_db_free_pkgcache(db);
|
|
/* cleanup server list */
|
|
FREELIST(db->servers);
|
|
FREE(db->_path);
|
|
FREE(db->treename);
|
|
FREE(db);
|
|
|
|
return;
|
|
}
|
|
|
|
const char *_alpm_db_path(pmdb_t *db)
|
|
{
|
|
if(!db) {
|
|
return(NULL);
|
|
}
|
|
if(!db->_path) {
|
|
const char *dbpath;
|
|
size_t pathsize;
|
|
|
|
dbpath = alpm_option_get_dbpath();
|
|
if(!dbpath) {
|
|
_alpm_log(PM_LOG_ERROR, _("database path is undefined\n"));
|
|
RET_ERR(PM_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));
|
|
sprintf(db->_path, "%s%s/", dbpath, db->treename);
|
|
} else {
|
|
pathsize = strlen(dbpath) + 5 + strlen(db->treename) + 2;
|
|
CALLOC(db->_path, 1, pathsize, RET_ERR(PM_ERR_MEMORY, NULL));
|
|
/* all sync DBs now reside in the sync/ subdir of the dbpath */
|
|
sprintf(db->_path, "%ssync/%s/", dbpath, db->treename);
|
|
}
|
|
_alpm_log(PM_LOG_DEBUG, "database path for tree %s set to %s\n",
|
|
db->treename, db->_path);
|
|
}
|
|
return(db->_path);
|
|
}
|
|
|
|
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_list_t *_alpm_db_search(pmdb_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;
|
|
|
|
if(i->data == NULL) {
|
|
continue;
|
|
}
|
|
ret = NULL;
|
|
targ = i->data;
|
|
_alpm_log(PM_LOG_DEBUG, "searching for target '%s'\n", targ);
|
|
|
|
if(regcomp(®, targ, REG_EXTENDED | REG_NOSUB | REG_ICASE | REG_NEWLINE) != 0) {
|
|
RET_ERR(PM_ERR_INVALID_REGEX, NULL);
|
|
}
|
|
|
|
for(j = list; j; j = j->next) {
|
|
pmpkg_t *pkg = j->data;
|
|
const char *matched = NULL;
|
|
const char *name = alpm_pkg_get_name(pkg);
|
|
const char *desc = alpm_pkg_get_desc(pkg);
|
|
|
|
/* check name as regex AND as plain text */
|
|
if(name && (regexec(®, name, 0, 0, 0) == 0 || strstr(name, targ))) {
|
|
matched = name;
|
|
}
|
|
/* check desc */
|
|
else if (desc && regexec(®, desc, 0, 0, 0) == 0) {
|
|
matched = desc;
|
|
}
|
|
/* TODO: should we be doing this, and should we print something
|
|
* differently when we do match it since it isn't currently printed? */
|
|
if(!matched) {
|
|
/* check provides */
|
|
for(k = alpm_pkg_get_provides(pkg); k; k = k->next) {
|
|
if (regexec(®, k->data, 0, 0, 0) == 0) {
|
|
matched = k->data;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(!matched) {
|
|
/* check groups */
|
|
for(k = alpm_pkg_get_groups(pkg); k; k = k->next) {
|
|
if (regexec(®, k->data, 0, 0, 0) == 0) {
|
|
matched = k->data;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(matched != NULL) {
|
|
_alpm_log(PM_LOG_DEBUG, " search target '%s' matched '%s'\n",
|
|
targ, matched);
|
|
ret = alpm_list_add(ret, pkg);
|
|
}
|
|
}
|
|
|
|
/* Free the existing search list, and use the returned list for the
|
|
* next needle. This allows for AND-based package searching. */
|
|
alpm_list_free(list);
|
|
list = ret;
|
|
regfree(®);
|
|
}
|
|
|
|
return(ret);
|
|
}
|
|
|
|
pmdb_t *_alpm_db_register_local(void)
|
|
{
|
|
pmdb_t *db;
|
|
|
|
ALPM_LOG_FUNC;
|
|
|
|
if(handle->db_local != NULL) {
|
|
_alpm_log(PM_LOG_WARNING, _("attempt to re-register the 'local' DB\n"));
|
|
RET_ERR(PM_ERR_DB_NOT_NULL, NULL);
|
|
}
|
|
|
|
_alpm_log(PM_LOG_DEBUG, "registering local database\n");
|
|
|
|
db = _alpm_db_new("local", 1);
|
|
if(db == NULL) {
|
|
RET_ERR(PM_ERR_DB_CREATE, NULL);
|
|
}
|
|
|
|
handle->db_local = db;
|
|
return(db);
|
|
}
|
|
|
|
pmdb_t *_alpm_db_register_sync(const char *treename)
|
|
{
|
|
pmdb_t *db;
|
|
alpm_list_t *i;
|
|
|
|
ALPM_LOG_FUNC;
|
|
|
|
for(i = handle->dbs_sync; i; i = i->next) {
|
|
pmdb_t *sdb = i->data;
|
|
if(strcmp(treename, sdb->treename) == 0) {
|
|
_alpm_log(PM_LOG_DEBUG, "attempt to re-register the '%s' database, using existing\n", sdb->treename);
|
|
return sdb;
|
|
}
|
|
}
|
|
|
|
_alpm_log(PM_LOG_DEBUG, "registering sync database '%s'\n", treename);
|
|
|
|
db = _alpm_db_new(treename, 0);
|
|
if(db == NULL) {
|
|
RET_ERR(PM_ERR_DB_CREATE, NULL);
|
|
}
|
|
|
|
handle->dbs_sync = alpm_list_add(handle->dbs_sync, db);
|
|
return(db);
|
|
}
|
|
|
|
/* vim: set ts=2 sw=2 noet: */
|