2005-03-14 20:51:43 -05:00
|
|
|
/*
|
|
|
|
* alpm.c
|
|
|
|
*
|
|
|
|
* Copyright (c) 2002 by Judd Vinet <jvinet@zeroflux.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, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
|
|
|
* USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <syslog.h>
|
|
|
|
#include <limits.h> /* PATH_MAX */
|
|
|
|
#include <stdarg.h>
|
|
|
|
/* pacman */
|
|
|
|
#include "log.h"
|
|
|
|
#include "error.h"
|
2005-12-26 11:48:37 -05:00
|
|
|
#include "versioncmp.h"
|
2005-03-14 20:51:43 -05:00
|
|
|
#include "md5.h"
|
|
|
|
#include "list.h"
|
|
|
|
#include "package.h"
|
|
|
|
#include "group.h"
|
|
|
|
#include "util.h"
|
|
|
|
#include "db.h"
|
|
|
|
#include "cache.h"
|
|
|
|
#include "deps.h"
|
|
|
|
#include "backup.h"
|
|
|
|
#include "add.h"
|
|
|
|
#include "remove.h"
|
|
|
|
#include "sync.h"
|
|
|
|
#include "handle.h"
|
|
|
|
#include "alpm.h"
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
#define PM_LOCK "/tmp/pacman.lck"
|
|
|
|
|
2005-03-16 17:06:31 -05:00
|
|
|
/* Globals */
|
2005-03-14 20:51:43 -05:00
|
|
|
pmhandle_t *handle = NULL;
|
|
|
|
enum __pmerrno_t pm_errno;
|
|
|
|
|
2005-12-19 18:32:16 -05:00
|
|
|
/** @defgroup alpm_interface Interface Functions
|
2005-10-09 03:42:06 -04:00
|
|
|
* @{
|
2005-03-14 20:51:43 -05:00
|
|
|
*/
|
|
|
|
|
2005-10-09 03:42:06 -04:00
|
|
|
/** Initializes the library. This must be called before any other
|
|
|
|
* functions are called.
|
|
|
|
* @param root the full path of the root we'll be installing to (usually /)
|
|
|
|
* @return 0 on success, -1 on error (pm_errno is set accordingly)
|
|
|
|
*/
|
2005-03-14 20:51:43 -05:00
|
|
|
int alpm_initialize(char *root)
|
|
|
|
{
|
|
|
|
char str[PATH_MAX];
|
|
|
|
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(handle == NULL, RET_ERR(PM_ERR_HANDLE_NOT_NULL, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
handle = handle_new();
|
2005-04-24 14:58:34 -04:00
|
|
|
if(handle == NULL) {
|
2005-04-24 16:11:10 -04:00
|
|
|
RET_ERR(PM_ERR_MEMORY, -1);
|
2005-04-24 14:58:34 -04:00
|
|
|
}
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
/* lock db */
|
|
|
|
if(handle->access == PM_ACCESS_RW) {
|
2005-10-05 17:50:58 -04:00
|
|
|
handle->lckfd = _alpm_lckmk(PM_LOCK);
|
|
|
|
if(handle->lckfd == -1) {
|
2005-03-14 20:51:43 -05:00
|
|
|
FREE(handle);
|
2005-03-16 17:10:05 -05:00
|
|
|
RET_ERR(PM_ERR_HANDLE_LOCK, -1);
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-03-29 12:18:59 -05:00
|
|
|
STRNCPY(str, (root) ? root : PM_ROOT, PATH_MAX);
|
2005-03-14 20:51:43 -05:00
|
|
|
/* add a trailing '/' if there isn't one */
|
|
|
|
if(str[strlen(str)-1] != '/') {
|
|
|
|
strcat(str, "/");
|
|
|
|
}
|
|
|
|
handle->root = strdup(str);
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2005-10-09 03:42:06 -04:00
|
|
|
/** Release the library. This should be the last alpm call you make.
|
|
|
|
* @return 0 on success, -1 on error (pm_errno is set accordingly)
|
|
|
|
*/
|
2005-03-14 20:51:43 -05:00
|
|
|
int alpm_release()
|
|
|
|
{
|
|
|
|
PMList *i;
|
|
|
|
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
/* unlock db */
|
|
|
|
if(handle->access == PM_ACCESS_RW) {
|
2005-10-05 17:50:58 -04:00
|
|
|
if(handle->lckfd != -1) {
|
|
|
|
close(handle->lckfd);
|
|
|
|
handle->lckfd = -1;
|
|
|
|
}
|
2005-03-16 14:18:09 -05:00
|
|
|
if(_alpm_lckrm(PM_LOCK)) {
|
|
|
|
_alpm_log(PM_LOG_WARNING, "could not remove lock file %s", PM_LOCK);
|
|
|
|
alpm_logaction("warning: could not remove lock file %s", PM_LOCK);
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* close local database */
|
|
|
|
if(handle->db_local) {
|
|
|
|
db_close(handle->db_local);
|
|
|
|
handle->db_local = NULL;
|
|
|
|
}
|
|
|
|
/* and also sync ones */
|
|
|
|
for(i = handle->dbs_sync; i; i = i->next) {
|
2005-04-24 16:11:10 -04:00
|
|
|
db_close(i->data);
|
|
|
|
i->data = NULL;
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
FREEHANDLE(handle);
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
2005-10-09 03:42:06 -04:00
|
|
|
/** @} */
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2005-12-19 18:32:16 -05:00
|
|
|
/** @defgroup alpm_options Library Options
|
2005-10-09 03:42:06 -04:00
|
|
|
* @{
|
2005-03-14 20:51:43 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
int alpm_set_option(unsigned char parm, unsigned long data)
|
|
|
|
{
|
|
|
|
/* Sanity checks */
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
return(handle_set_option(handle, parm, data));
|
|
|
|
}
|
|
|
|
|
|
|
|
int alpm_get_option(unsigned char parm, long *data)
|
|
|
|
{
|
|
|
|
/* Sanity checks */
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
|
|
|
ASSERT(data != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
return(handle_get_option(handle, parm, data));
|
|
|
|
}
|
2005-10-09 03:42:06 -04:00
|
|
|
/** @} */
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2005-12-19 18:32:16 -05:00
|
|
|
/** @defgroup alpm_databases Database Functions
|
2005-10-09 03:42:06 -04:00
|
|
|
* @{
|
2005-03-14 20:51:43 -05:00
|
|
|
*/
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
pmdb_t *alpm_db_register(char *treename)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
2005-03-29 15:52:22 -05:00
|
|
|
pmdb_t *db;
|
2005-05-02 13:54:44 -04:00
|
|
|
int found = 0;
|
2005-03-29 15:52:22 -05:00
|
|
|
|
2005-03-14 20:51:43 -05:00
|
|
|
/* Sanity checks */
|
2005-03-29 15:52:22 -05:00
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, NULL));
|
|
|
|
ASSERT(treename != NULL && strlen(treename) != 0, RET_ERR(PM_ERR_WRONG_ARGS, NULL));
|
2006-01-02 11:20:50 -05:00
|
|
|
/* Do not register a database if a transaction is on-going */
|
|
|
|
ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, NULL));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2005-05-02 13:54:44 -04:00
|
|
|
if(strcmp(treename, "local") == 0) {
|
|
|
|
if(handle->db_local != NULL) {
|
|
|
|
found = 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
PMList *i;
|
|
|
|
for(i = handle->dbs_sync; i && !found; i = i->next) {
|
|
|
|
pmdb_t *sdb = i->data;
|
|
|
|
if(strcmp(treename, sdb->treename) == 0) {
|
|
|
|
found = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(found) {
|
|
|
|
RET_ERR(PM_ERR_DB_NOT_NULL, NULL);
|
|
|
|
}
|
2005-03-16 17:06:31 -05:00
|
|
|
|
2005-03-29 15:52:22 -05:00
|
|
|
db = db_open(handle->root, handle->dbpath, treename);
|
|
|
|
if(db == NULL) {
|
2005-03-14 20:51:43 -05:00
|
|
|
/* couldn't open the db directory - try creating it */
|
|
|
|
if(db_create(handle->root, handle->dbpath, treename) == -1) {
|
2005-03-29 15:52:22 -05:00
|
|
|
RET_ERR(PM_ERR_DB_CREATE, NULL);
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
2005-03-29 15:52:22 -05:00
|
|
|
db = db_open(handle->root, handle->dbpath, treename);
|
|
|
|
if(db == NULL) {
|
|
|
|
/* couldn't open the db directory */
|
|
|
|
RET_ERR(PM_ERR_DB_OPEN, NULL);
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(strcmp(treename, "local") == 0) {
|
2005-03-29 15:52:22 -05:00
|
|
|
handle->db_local = db;
|
2005-03-14 20:51:43 -05:00
|
|
|
} else {
|
2005-03-29 15:52:22 -05:00
|
|
|
handle->dbs_sync = pm_list_add(handle->dbs_sync, db);
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
|
2005-03-29 15:52:22 -05:00
|
|
|
return(db);
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
|
2005-05-03 13:43:02 -04:00
|
|
|
/* Helper function for comparing databases
|
|
|
|
*/
|
|
|
|
static int db_cmp(const void *db1, const void *db2)
|
|
|
|
{
|
|
|
|
return(strcmp(((pmdb_t *)db1)->treename, ((pmdb_t *)db2)->treename));
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
int alpm_db_unregister(pmdb_t *db)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
|
|
|
int found = 0;
|
|
|
|
|
|
|
|
/* Sanity checks */
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
|
|
|
ASSERT(db != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
|
2006-01-02 11:20:50 -05:00
|
|
|
/* Do not unregister a database if a transaction is on-going */
|
2006-01-02 15:28:46 -05:00
|
|
|
ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
if(db == handle->db_local) {
|
|
|
|
db_close(handle->db_local);
|
|
|
|
handle->db_local = NULL;
|
|
|
|
found = 1;
|
|
|
|
} else {
|
2005-05-03 13:44:53 -04:00
|
|
|
pmdb_t *data;
|
|
|
|
handle->dbs_sync = _alpm_list_remove(handle->dbs_sync, db, db_cmp, (void **)&data);
|
2005-05-03 13:43:02 -04:00
|
|
|
if(data) {
|
|
|
|
db_close(data);
|
|
|
|
found = 1;
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!found) {
|
2005-03-16 17:10:05 -05:00
|
|
|
RET_ERR(PM_ERR_DB_NOT_FOUND, -1);
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2005-04-02 18:20:00 -05:00
|
|
|
void *alpm_db_getinfo(PM_DB *db, unsigned char parm)
|
2005-03-16 14:31:20 -05:00
|
|
|
{
|
2005-04-02 18:20:00 -05:00
|
|
|
void *data = NULL;
|
|
|
|
|
2005-03-16 14:31:20 -05:00
|
|
|
/* Sanity checks */
|
2005-04-02 18:20:00 -05:00
|
|
|
ASSERT(handle != NULL, return(NULL));
|
|
|
|
ASSERT(db != NULL, return(NULL));
|
2005-03-20 04:22:03 -05:00
|
|
|
|
2005-04-02 18:20:00 -05:00
|
|
|
switch(parm) {
|
|
|
|
case PM_DB_TREENAME: data = db->treename; break;
|
|
|
|
case PM_DB_LASTUPDATE: data = db->lastupdate; break;
|
|
|
|
default:
|
|
|
|
data = NULL;
|
2005-03-22 15:14:49 -05:00
|
|
|
}
|
|
|
|
|
2005-04-02 18:20:00 -05:00
|
|
|
return(data);
|
2005-03-20 04:22:03 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
int alpm_db_update(PM_DB *db, char *archive, char *ts)
|
|
|
|
{
|
2005-10-07 12:38:17 -04:00
|
|
|
PMList *lp;
|
2005-03-29 17:19:11 -05:00
|
|
|
|
2005-03-20 04:22:03 -05:00
|
|
|
/* Sanity checks */
|
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
2005-03-22 15:14:49 -05:00
|
|
|
ASSERT(db != NULL && db != handle->db_local, RET_ERR(PM_ERR_WRONG_ARGS, -1));
|
2006-01-02 11:20:50 -05:00
|
|
|
/* Do not update a database if a transaction is on-going */
|
2006-01-02 15:28:46 -05:00
|
|
|
ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, -1));
|
2005-03-22 15:14:49 -05:00
|
|
|
|
2005-04-23 04:28:13 -04:00
|
|
|
if(!pm_list_is_in(db, handle->dbs_sync)) {
|
2005-03-22 15:14:49 -05:00
|
|
|
RET_ERR(PM_ERR_DB_NOT_FOUND, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(ts && strlen(ts) != 0) {
|
|
|
|
char lastupdate[15];
|
|
|
|
if(db_getlastupdate(db, lastupdate) != -1) {
|
|
|
|
if(strcmp(ts, lastupdate) == 0) {
|
|
|
|
RET_ERR(PM_ERR_DB_UPTODATE, -1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-03-20 04:22:03 -05:00
|
|
|
|
2005-10-22 04:29:12 -04:00
|
|
|
/* remove the old dir */
|
|
|
|
_alpm_log(PM_LOG_FLOW2, "flushing database %s/%s", handle->dbpath, db->treename);
|
|
|
|
for(lp = db_get_pkgcache(db); lp; lp = lp->next) {
|
|
|
|
if(db_remove(db, lp->data) == -1) {
|
|
|
|
if(lp->data) {
|
|
|
|
_alpm_log(PM_LOG_ERROR, "could not remove database entry %s/%s", db->treename,
|
|
|
|
((pmpkg_t *)lp->data)->name);
|
|
|
|
}
|
|
|
|
RET_ERR(PM_ERR_XXX, -1);
|
|
|
|
}
|
2005-03-29 17:19:11 -05:00
|
|
|
}
|
2005-03-20 04:22:03 -05:00
|
|
|
|
2005-03-26 03:50:27 -05:00
|
|
|
/* Cache needs to be rebuild */
|
|
|
|
db_free_pkgcache(db);
|
|
|
|
|
2005-03-22 15:14:49 -05:00
|
|
|
/* uncompress the sync database */
|
2005-03-16 14:31:20 -05:00
|
|
|
/* ORE
|
2005-03-22 15:14:49 -05:00
|
|
|
we should not simply unpack the archive, but better parse it and
|
2005-11-07 08:01:10 -05:00
|
|
|
db_write each entry (see sync_load_dbarchive to get archive content) */
|
2005-03-28 03:21:17 -05:00
|
|
|
_alpm_log(PM_LOG_FLOW2, "unpacking %s", archive);
|
2005-03-22 15:14:49 -05:00
|
|
|
if(_alpm_unpack(archive, db->path, NULL)) {
|
|
|
|
RET_ERR(PM_ERR_XXX, -1);
|
|
|
|
}
|
2005-03-16 14:31:20 -05:00
|
|
|
|
2005-03-22 15:14:49 -05:00
|
|
|
if(ts && strlen(ts) != 0) {
|
|
|
|
if(db_setlastupdate(db, ts) == -1) {
|
|
|
|
RET_ERR(PM_ERR_XXX, -1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return(0);
|
2005-03-16 14:31:20 -05:00
|
|
|
}
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
pmpkg_t *alpm_db_readpkg(pmdb_t *db, char *name)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
|
|
|
/* Sanity checks */
|
|
|
|
ASSERT(handle != NULL, return(NULL));
|
|
|
|
ASSERT(db != NULL, return(NULL));
|
|
|
|
ASSERT(name != NULL && strlen(name) != 0, return(NULL));
|
|
|
|
|
|
|
|
return(db_get_pkgfromcache(db, name));
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
PMList *alpm_db_getpkgcache(pmdb_t *db)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
|
|
|
/* Sanity checks */
|
|
|
|
ASSERT(handle != NULL, return(NULL));
|
|
|
|
ASSERT(db != NULL, return(NULL));
|
|
|
|
|
|
|
|
return(db_get_pkgcache(db));
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
pmgrp_t *alpm_db_readgrp(pmdb_t *db, char *name)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
|
|
|
/* Sanity checks */
|
|
|
|
ASSERT(handle != NULL, return(NULL));
|
|
|
|
ASSERT(db != NULL, return(NULL));
|
|
|
|
ASSERT(name != NULL && strlen(name) != 0, return(NULL));
|
|
|
|
|
|
|
|
return(db_get_grpfromcache(db, name));
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
PMList *alpm_db_getgrpcache(pmdb_t *db)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
|
|
|
/* Sanity checks */
|
|
|
|
ASSERT(handle != NULL, return(NULL));
|
|
|
|
ASSERT(db != NULL, return(NULL));
|
|
|
|
|
|
|
|
return(db_get_grpcache(db));
|
|
|
|
}
|
2005-10-09 03:42:06 -04:00
|
|
|
/** @} */
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2005-12-19 18:32:16 -05:00
|
|
|
/** @defgroup alpm_packages Package Functions
|
2005-10-09 03:42:06 -04:00
|
|
|
* @{
|
2005-03-14 20:51:43 -05:00
|
|
|
*/
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
void *alpm_pkg_getinfo(pmpkg_t *pkg, unsigned char parm)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
2005-04-02 18:20:00 -05:00
|
|
|
void *data = NULL;
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
/* Sanity checks */
|
|
|
|
ASSERT(handle != NULL, return(NULL));
|
|
|
|
ASSERT(pkg != NULL, return(NULL));
|
|
|
|
|
|
|
|
/* Update the cache package entry if needed */
|
2005-04-08 16:42:27 -04:00
|
|
|
if(pkg->origin == PKG_FROM_CACHE) {
|
2005-03-14 20:51:43 -05:00
|
|
|
switch(parm) {
|
2005-04-08 16:42:27 -04:00
|
|
|
/* Desc entry */
|
|
|
|
case PM_PKG_NAME:
|
|
|
|
case PM_PKG_VERSION:
|
|
|
|
case PM_PKG_DESC:
|
|
|
|
case PM_PKG_GROUPS:
|
|
|
|
case PM_PKG_URL:
|
|
|
|
case PM_PKG_LICENSE:
|
|
|
|
case PM_PKG_ARCH:
|
|
|
|
case PM_PKG_BUILDDATE:
|
|
|
|
case PM_PKG_INSTALLDATE:
|
|
|
|
case PM_PKG_PACKAGER:
|
|
|
|
case PM_PKG_SIZE:
|
|
|
|
case PM_PKG_REASON:
|
|
|
|
case PM_PKG_MD5SUM:
|
|
|
|
if(!(pkg->infolevel & INFRQ_DESC)) {
|
2005-10-08 17:36:47 -04:00
|
|
|
char target[PKG_FULLNAME_LEN];
|
|
|
|
snprintf(target, PKG_FULLNAME_LEN, "%s-%s", pkg->name, pkg->version);
|
2005-04-08 16:42:27 -04:00
|
|
|
db_read(pkg->data, target, INFRQ_DESC, pkg);
|
|
|
|
}
|
2005-10-08 17:32:14 -04:00
|
|
|
break;
|
2005-04-08 16:42:27 -04:00
|
|
|
/* Depends entry */
|
2005-10-10 11:03:35 -04:00
|
|
|
/* not needed: the cache is loaded with DEPENDS by default
|
2005-04-08 16:42:27 -04:00
|
|
|
case PM_PKG_DEPENDS:
|
|
|
|
case PM_PKG_REQUIREDBY:
|
|
|
|
case PM_PKG_CONFLICTS:
|
|
|
|
case PM_PKG_PROVIDES:
|
2005-10-08 16:43:25 -04:00
|
|
|
case PM_PKG_REPLACES:
|
2005-04-08 16:42:27 -04:00
|
|
|
if(!(pkg->infolevel & INFRQ_DEPENDS)) {
|
2005-10-08 17:36:47 -04:00
|
|
|
char target[PKG_FULLNAME_LEN];
|
|
|
|
snprintf(target, PKG_FULLNAME_LEN, "%s-%s", pkg->name, pkg->version);
|
2005-04-08 16:42:27 -04:00
|
|
|
db_read(pkg->data, target, INFRQ_DEPENDS, pkg);
|
|
|
|
}
|
|
|
|
break;*/
|
|
|
|
/* Files entry */
|
2005-03-14 20:51:43 -05:00
|
|
|
case PM_PKG_FILES:
|
|
|
|
case PM_PKG_BACKUP:
|
2005-04-08 16:42:27 -04:00
|
|
|
if(pkg->data == handle->db_local && !(pkg->infolevel & INFRQ_FILES)) {
|
2005-10-08 17:36:47 -04:00
|
|
|
char target[PKG_FULLNAME_LEN];
|
|
|
|
snprintf(target, PKG_FULLNAME_LEN, "%s-%s", pkg->name, pkg->version);
|
2005-04-08 16:42:27 -04:00
|
|
|
db_read(pkg->data, target, INFRQ_FILES, pkg);
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
break;
|
2005-04-08 16:42:27 -04:00
|
|
|
/* Scriptlet */
|
2005-03-14 20:51:43 -05:00
|
|
|
case PM_PKG_SCRIPLET:
|
2005-04-08 16:42:27 -04:00
|
|
|
if(pkg->data == handle->db_local && !(pkg->infolevel & INFRQ_SCRIPLET)) {
|
2005-10-08 17:36:47 -04:00
|
|
|
char target[PKG_FULLNAME_LEN];
|
|
|
|
snprintf(target, PKG_FULLNAME_LEN, "%s-%s", pkg->name, pkg->version);
|
2005-03-14 20:51:43 -05:00
|
|
|
db_read(pkg->data, target, INFRQ_SCRIPLET, pkg);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(parm) {
|
|
|
|
case PM_PKG_NAME: data = pkg->name; break;
|
|
|
|
case PM_PKG_VERSION: data = pkg->version; break;
|
|
|
|
case PM_PKG_DESC: data = pkg->desc; break;
|
|
|
|
case PM_PKG_GROUPS: data = pkg->groups; break;
|
|
|
|
case PM_PKG_URL: data = pkg->url; break;
|
|
|
|
case PM_PKG_ARCH: data = pkg->arch; break;
|
|
|
|
case PM_PKG_BUILDDATE: data = pkg->builddate; break;
|
|
|
|
case PM_PKG_INSTALLDATE: data = pkg->installdate; break;
|
|
|
|
case PM_PKG_PACKAGER: data = pkg->packager; break;
|
|
|
|
case PM_PKG_SIZE: data = (void *)pkg->size; break;
|
|
|
|
case PM_PKG_REASON: data = (void *)(int)pkg->reason; break;
|
2005-07-21 21:59:11 -04:00
|
|
|
case PM_PKG_LICENSE: data = pkg->license; break;
|
2005-03-14 20:51:43 -05:00
|
|
|
case PM_PKG_REPLACES: data = pkg->replaces; break;
|
|
|
|
case PM_PKG_MD5SUM: data = pkg->md5sum; break;
|
|
|
|
case PM_PKG_DEPENDS: data = pkg->depends; break;
|
|
|
|
case PM_PKG_REQUIREDBY: data = pkg->requiredby; break;
|
|
|
|
case PM_PKG_PROVIDES: data = pkg->provides; break;
|
|
|
|
case PM_PKG_CONFLICTS: data = pkg->conflicts; break;
|
|
|
|
case PM_PKG_FILES: data = pkg->files; break;
|
|
|
|
case PM_PKG_BACKUP: data = pkg->backup; break;
|
|
|
|
case PM_PKG_SCRIPLET: data = (void *)(int)pkg->scriptlet; break;
|
2005-04-16 18:23:28 -04:00
|
|
|
case PM_PKG_DATA: data = pkg->data; break;
|
2005-03-14 20:51:43 -05:00
|
|
|
default:
|
|
|
|
data = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return(data);
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
int alpm_pkg_load(char *filename, pmpkg_t **pkg)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
|
|
|
/* Sanity checks */
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(filename != NULL && strlen(filename) != 0, RET_ERR(PM_ERR_WRONG_ARGS, -1));
|
|
|
|
ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
*pkg = pkg_load(filename);
|
|
|
|
if(*pkg == NULL) {
|
|
|
|
/* pm_errno is set by pkg_load */
|
|
|
|
return(-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2005-10-10 11:03:35 -04:00
|
|
|
int alpm_pkg_free(pmpkg_t *pkg)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
2005-10-10 11:03:35 -04:00
|
|
|
ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
|
|
|
|
ASSERT(pkg->origin != PKG_FROM_CACHE, RET_ERR(PM_ERR_XXX, -1));
|
|
|
|
|
2005-03-14 20:51:43 -05:00
|
|
|
pkg_free(pkg);
|
2005-10-10 11:03:35 -04:00
|
|
|
|
|
|
|
return(0);
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
int alpm_pkg_vercmp(const char *ver1, const char *ver2)
|
|
|
|
{
|
2005-12-26 11:48:37 -05:00
|
|
|
return(versioncmp(ver1, ver2));
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
2005-10-09 03:42:06 -04:00
|
|
|
/** @} */
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2005-12-19 18:32:16 -05:00
|
|
|
/** @defgroup alpm_groups Group Functions
|
2005-10-09 03:42:06 -04:00
|
|
|
* @{
|
2005-03-14 20:51:43 -05:00
|
|
|
*/
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
void *alpm_grp_getinfo(pmgrp_t *grp, unsigned char parm)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
2005-04-02 18:20:00 -05:00
|
|
|
void *data = NULL;
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
/* Sanity checks */
|
|
|
|
ASSERT(grp != NULL, return(NULL));
|
|
|
|
|
|
|
|
switch(parm) {
|
|
|
|
case PM_GRP_NAME: data = grp->name; break;
|
|
|
|
case PM_GRP_PKGNAMES: data = grp->packages; break;
|
|
|
|
default:
|
|
|
|
data = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return(data);
|
|
|
|
}
|
2005-10-09 03:42:06 -04:00
|
|
|
/** @} */
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2005-12-19 18:32:16 -05:00
|
|
|
/** @defgroup alpm_sync Sync Functions
|
2005-10-09 03:42:06 -04:00
|
|
|
* @{
|
2005-03-14 20:51:43 -05:00
|
|
|
*/
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
void *alpm_sync_getinfo(pmsyncpkg_t *sync, unsigned char parm)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
|
|
|
void *data;
|
|
|
|
|
|
|
|
/* Sanity checks */
|
|
|
|
ASSERT(sync != NULL, return(NULL));
|
|
|
|
|
|
|
|
switch(parm) {
|
2005-04-20 16:50:17 -04:00
|
|
|
case PM_SYNC_TYPE: data = (void *)(int)sync->type; break;
|
|
|
|
case PM_SYNC_PKG: data = sync->pkg; break;
|
|
|
|
case PM_SYNC_DATA: data = sync->data; break;
|
2005-03-14 20:51:43 -05:00
|
|
|
default:
|
|
|
|
data = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return(data);
|
|
|
|
}
|
2005-10-09 03:42:06 -04:00
|
|
|
/** @} */
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2005-12-19 18:32:16 -05:00
|
|
|
/** @defgroup alpm_trans Transaction Functions
|
2005-10-09 03:42:06 -04:00
|
|
|
* @{
|
2005-03-14 20:51:43 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
void *alpm_trans_getinfo(unsigned char parm)
|
|
|
|
{
|
|
|
|
pmtrans_t *trans;
|
|
|
|
void *data;
|
|
|
|
|
|
|
|
/* Sanity checks */
|
|
|
|
ASSERT(handle != NULL, return(NULL));
|
2005-10-10 11:03:35 -04:00
|
|
|
ASSERT(handle->trans != NULL, return(NULL));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
trans = handle->trans;
|
|
|
|
|
|
|
|
switch(parm) {
|
2005-04-02 15:33:11 -05:00
|
|
|
case PM_TRANS_TYPE: data = (void *)(int)trans->type; break;
|
|
|
|
case PM_TRANS_FLAGS: data = (void *)(int)trans->flags; break;
|
|
|
|
case PM_TRANS_TARGETS: data = trans->targets; break;
|
2005-04-06 17:00:57 -04:00
|
|
|
case PM_TRANS_PACKAGES: data = trans->packages; break;
|
2005-03-14 20:51:43 -05:00
|
|
|
default:
|
|
|
|
data = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return(data);
|
|
|
|
}
|
|
|
|
|
2005-10-09 02:09:57 -04:00
|
|
|
int alpm_trans_init(unsigned char type, unsigned char flags, alpm_trans_cb_event event, alpm_trans_cb_conv conv)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
|
|
|
/* Sanity checks */
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
handle->trans = trans_new();
|
|
|
|
if(handle->trans == NULL) {
|
2005-03-16 17:10:05 -05:00
|
|
|
RET_ERR(PM_ERR_MEMORY, -1);
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
|
2005-10-09 02:09:57 -04:00
|
|
|
return(trans_init(handle->trans, type, flags, event, conv));
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
int alpm_trans_sysupgrade()
|
|
|
|
{
|
|
|
|
pmtrans_t *trans;
|
|
|
|
|
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
|
|
|
|
|
|
|
trans = handle->trans;
|
|
|
|
ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
|
|
|
|
ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(PM_ERR_TRANS_NOT_INITIALIZED, -1));
|
|
|
|
ASSERT(trans->type == PM_TRANS_TYPE_SYNC, RET_ERR(PM_ERR_XXX, -1));
|
|
|
|
|
|
|
|
return(trans_sysupgrade(trans));
|
|
|
|
}
|
|
|
|
|
2005-03-14 20:51:43 -05:00
|
|
|
int alpm_trans_addtarget(char *target)
|
|
|
|
{
|
|
|
|
pmtrans_t *trans;
|
|
|
|
|
|
|
|
/* Sanity checks */
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
|
|
|
ASSERT(target != NULL && strlen(target) != 0, RET_ERR(PM_ERR_WRONG_ARGS, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
trans = handle->trans;
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
|
|
|
|
ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(PM_ERR_TRANS_NOT_INITIALIZED, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
return(trans_addtarget(trans, target));
|
|
|
|
}
|
|
|
|
|
|
|
|
int alpm_trans_prepare(PMList **data)
|
|
|
|
{
|
|
|
|
pmtrans_t *trans;
|
|
|
|
|
|
|
|
/* Sanity checks */
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
|
|
|
ASSERT(data != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
trans = handle->trans;
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
|
|
|
|
ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(PM_ERR_TRANS_NOT_INITIALIZED, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
return(trans_prepare(handle->trans, data));
|
|
|
|
}
|
|
|
|
|
|
|
|
int alpm_trans_commit()
|
|
|
|
{
|
|
|
|
pmtrans_t *trans;
|
|
|
|
|
|
|
|
/* Sanity checks */
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
trans = handle->trans;
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
|
|
|
|
ASSERT(trans->state == STATE_PREPARED, RET_ERR(PM_ERR_TRANS_NOT_PREPARED, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2005-10-08 19:40:49 -04:00
|
|
|
/* Check for database R/W permission */
|
|
|
|
ASSERT(handle->access == PM_ACCESS_RW, RET_ERR(PM_ERR_BADPERMS, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
return(trans_commit(handle->trans));
|
|
|
|
}
|
|
|
|
|
|
|
|
int alpm_trans_release()
|
|
|
|
{
|
|
|
|
pmtrans_t *trans;
|
|
|
|
|
|
|
|
/* Sanity checks */
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
trans = handle->trans;
|
2005-03-16 17:10:05 -05:00
|
|
|
ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
|
|
|
|
ASSERT(trans->state != STATE_IDLE, RET_ERR(PM_ERR_TRANS_NULL, -1));
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
FREETRANS(handle->trans);
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
2005-10-09 03:42:06 -04:00
|
|
|
/** @} */
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2005-12-19 18:32:16 -05:00
|
|
|
/** @defgroup alpm_dep Dependency Functions
|
2005-10-09 03:42:06 -04:00
|
|
|
* @{
|
2005-03-29 15:31:03 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
void *alpm_dep_getinfo(pmdepmissing_t *miss, unsigned char parm)
|
|
|
|
{
|
|
|
|
void *data;
|
|
|
|
|
|
|
|
/* Sanity checks */
|
|
|
|
ASSERT(miss != NULL, return(NULL));
|
|
|
|
|
|
|
|
switch(parm) {
|
|
|
|
case PM_DEP_TARGET: data = (void *)(int)miss->target; break;
|
|
|
|
case PM_DEP_TYPE: data = (void *)(int)miss->type; break;
|
|
|
|
case PM_DEP_MOD: data = (void *)(int)miss->depend.mod; break;
|
|
|
|
case PM_DEP_NAME: data = miss->depend.name; break;
|
|
|
|
case PM_DEP_VERSION: data = miss->depend.version; break;
|
|
|
|
default:
|
|
|
|
data = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return(data);
|
|
|
|
}
|
2005-10-09 03:42:06 -04:00
|
|
|
/** @} */
|
2005-03-29 15:31:03 -05:00
|
|
|
|
2005-12-19 18:32:16 -05:00
|
|
|
/** @defgroup alpm_log Logging Functions
|
2005-10-09 03:42:06 -04:00
|
|
|
* @{
|
2005-03-14 20:51:43 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
int alpm_logaction(char *fmt, ...)
|
|
|
|
{
|
2005-03-16 14:50:57 -05:00
|
|
|
char str[LOG_STR_LEN];
|
2005-03-14 20:51:43 -05:00
|
|
|
va_list args;
|
|
|
|
|
2005-03-18 13:33:55 -05:00
|
|
|
/* Sanity checks */
|
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
|
|
|
|
2005-03-14 20:51:43 -05:00
|
|
|
va_start(args, fmt);
|
2005-03-16 14:50:57 -05:00
|
|
|
vsnprintf(str, LOG_STR_LEN, fmt, args);
|
2005-03-14 20:51:43 -05:00
|
|
|
va_end(args);
|
|
|
|
|
2005-03-18 13:33:55 -05:00
|
|
|
/* ORE
|
|
|
|
We should add a prefix to log strings depending on who called us.
|
|
|
|
If logaction was called by the frontend:
|
|
|
|
USER: <the frontend log>
|
|
|
|
and if called internally:
|
|
|
|
ALPM: <the library log>
|
|
|
|
Moreover, the frontend should be able to choose its prefix (USER by default?):
|
|
|
|
pacman: "PACMAN"
|
|
|
|
kpacman: "KPACMAN"
|
|
|
|
...
|
|
|
|
It allows to share the log file between several frontends and to actually
|
|
|
|
know who does what */
|
|
|
|
|
2005-03-14 20:51:43 -05:00
|
|
|
return(_alpm_log_action(handle->usesyslog, handle->logfd, str));
|
|
|
|
}
|
2005-10-09 03:42:06 -04:00
|
|
|
/** @} */
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2005-12-19 18:32:16 -05:00
|
|
|
/** @defgroup alpm_list List Manipulation Functions
|
2005-10-09 03:42:06 -04:00
|
|
|
* @{
|
2005-03-14 20:51:43 -05:00
|
|
|
*/
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
PMList *alpm_list_first(PMList *list)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
|
|
|
ASSERT(list != NULL, return(NULL));
|
|
|
|
|
|
|
|
return(list);
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
PMList *alpm_list_next(PMList *entry)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
|
|
|
ASSERT(entry != NULL, return(NULL));
|
|
|
|
|
|
|
|
return(entry->next);
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
void *alpm_list_getdata(PMList *entry)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
|
|
|
ASSERT(entry != NULL, return(NULL));
|
|
|
|
|
|
|
|
return(entry->data);
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:23:28 -04:00
|
|
|
int alpm_list_free(PMList *entry)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
2005-04-24 14:58:34 -04:00
|
|
|
FREELIST(entry);
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
2005-10-09 03:42:06 -04:00
|
|
|
/** @} */
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2005-12-19 18:32:16 -05:00
|
|
|
/** @defgroup alpm_misc Miscellaneous Functions
|
2005-10-09 03:42:06 -04:00
|
|
|
* @{
|
2005-03-14 20:51:43 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
char *alpm_get_md5sum(char *name)
|
|
|
|
{
|
|
|
|
ASSERT(name != NULL, return(NULL));
|
|
|
|
|
|
|
|
return(MDFile(name));
|
|
|
|
}
|
2005-10-09 03:42:06 -04:00
|
|
|
/* @} */
|
2005-03-14 20:51:43 -05:00
|
|
|
|
|
|
|
/* vim: set ts=2 sw=2 noet: */
|