summaryrefslogtreecommitdiffstats
path: root/lib/libalpm
diff options
context:
space:
mode:
Diffstat (limited to 'lib/libalpm')
-rw-r--r--lib/libalpm/Makefile.am11
-rw-r--r--lib/libalpm/add.c411
-rw-r--r--lib/libalpm/add.h2
-rw-r--r--lib/libalpm/alpm.c97
-rw-r--r--lib/libalpm/alpm.h958
-rw-r--r--lib/libalpm/alpm_list.c175
-rw-r--r--lib/libalpm/alpm_list.h3
-rw-r--r--lib/libalpm/backup.c95
-rw-r--r--lib/libalpm/backup.h8
-rw-r--r--lib/libalpm/base64.c190
-rw-r--r--lib/libalpm/base64.h68
-rw-r--r--lib/libalpm/be_local.c601
-rw-r--r--lib/libalpm/be_package.c292
-rw-r--r--lib/libalpm/be_sync.c498
-rw-r--r--lib/libalpm/conflict.c545
-rw-r--r--lib/libalpm/conflict.h29
-rw-r--r--lib/libalpm/db.c560
-rw-r--r--lib/libalpm/db.h81
-rw-r--r--lib/libalpm/delta.c166
-rw-r--r--lib/libalpm/delta.h24
-rw-r--r--lib/libalpm/deps.c430
-rw-r--r--lib/libalpm/deps.h31
-rw-r--r--lib/libalpm/diskspace.c156
-rw-r--r--lib/libalpm/diskspace.h2
-rw-r--r--lib/libalpm/dload.c646
-rw-r--r--lib/libalpm/dload.h20
-rw-r--r--lib/libalpm/error.c133
-rw-r--r--lib/libalpm/graph.c41
-rw-r--r--lib/libalpm/graph.h34
-rw-r--r--lib/libalpm/group.c36
-rw-r--r--lib/libalpm/group.h11
-rw-r--r--lib/libalpm/handle.c589
-rw-r--r--lib/libalpm/handle.h49
-rw-r--r--lib/libalpm/log.c30
-rw-r--r--lib/libalpm/log.h10
-rw-r--r--lib/libalpm/package.c398
-rw-r--r--lib/libalpm/package.h104
-rw-r--r--lib/libalpm/pkghash.c85
-rw-r--r--lib/libalpm/pkghash.h18
-rw-r--r--lib/libalpm/po/Makevars2
-rw-r--r--lib/libalpm/po/ca.po57
-rw-r--r--lib/libalpm/po/cs.po57
-rw-r--r--lib/libalpm/po/da.po51
-rw-r--r--lib/libalpm/po/de.po57
-rw-r--r--lib/libalpm/po/el.po57
-rw-r--r--lib/libalpm/po/en_GB.po57
-rw-r--r--lib/libalpm/po/es.po57
-rw-r--r--lib/libalpm/po/fi.po56
-rw-r--r--lib/libalpm/po/fr.po58
-rw-r--r--lib/libalpm/po/hu.po57
-rw-r--r--lib/libalpm/po/it.po59
-rw-r--r--lib/libalpm/po/kk.po57
-rw-r--r--lib/libalpm/po/libalpm.pot38
-rw-r--r--lib/libalpm/po/nb.po57
-rw-r--r--lib/libalpm/po/pl.po57
-rw-r--r--lib/libalpm/po/pt.po57
-rw-r--r--lib/libalpm/po/pt_BR.po57
-rw-r--r--lib/libalpm/po/ro.po61
-rw-r--r--lib/libalpm/po/ru.po57
-rw-r--r--lib/libalpm/po/sk.po58
-rw-r--r--lib/libalpm/po/sr.po57
-rw-r--r--lib/libalpm/po/sr@latin.po57
-rw-r--r--lib/libalpm/po/sv.po51
-rw-r--r--lib/libalpm/po/tr.po57
-rw-r--r--lib/libalpm/po/uk.po51
-rw-r--r--lib/libalpm/po/zh_CN.po57
-rw-r--r--lib/libalpm/rawstr.c137
-rw-r--r--lib/libalpm/remove.c486
-rw-r--r--lib/libalpm/remove.h8
-rw-r--r--lib/libalpm/signing.c548
-rw-r--r--lib/libalpm/signing.h32
-rw-r--r--lib/libalpm/sync.c606
-rw-r--r--lib/libalpm/sync.h4
-rw-r--r--lib/libalpm/trans.c272
-rw-r--r--lib/libalpm/trans.h24
-rw-r--r--lib/libalpm/util.c466
-rw-r--r--lib/libalpm/util.h50
-rw-r--r--lib/libalpm/version.c14
78 files changed, 6780 insertions, 4958 deletions
diff --git a/lib/libalpm/Makefile.am b/lib/libalpm/Makefile.am
index 1bda5714..c863fa9b 100644
--- a/lib/libalpm/Makefile.am
+++ b/lib/libalpm/Makefile.am
@@ -35,13 +35,15 @@ libalpm_la_SOURCES = \
diskspace.h diskspace.c \
dload.h dload.c \
error.c \
- graph.h \
+ graph.h graph.c \
group.h group.c \
handle.h handle.c \
log.h log.c \
package.h package.c \
pkghash.h pkghash.c \
+ rawstr.c \
remove.h remove.c \
+ signing.c signing.h \
sync.h sync.c \
trans.h trans.c \
util.h util.c \
@@ -52,7 +54,12 @@ libalpm_la_SOURCES += \
md5.h md5.c
endif
-libalpm_la_LDFLAGS = -no-undefined -version-info $(LIB_VERSION_INFO)
+if HAVE_LIBGPGME
+libalpm_la_SOURCES += \
+ base64.h base64.c
+endif
+
+libalpm_la_LDFLAGS = -no-undefined -version-info $(LIB_VERSION_INFO) @LIBCURL@
libalpm_la_LIBADD = $(LTLIBINTL)
# vim:set ts=2 sw=2 noet:
diff --git a/lib/libalpm/add.c b/lib/libalpm/add.c
index ad6ef17e..5e1bb8da 100644
--- a/lib/libalpm/add.c
+++ b/lib/libalpm/add.c
@@ -37,82 +37,76 @@
/* libalpm */
#include "add.h"
+#include "alpm.h"
#include "alpm_list.h"
+#include "handle.h"
#include "trans.h"
#include "util.h"
#include "log.h"
#include "backup.h"
#include "package.h"
#include "db.h"
-#include "conflict.h"
-#include "deps.h"
#include "remove.h"
#include "handle.h"
-/** Add a package to the transaction.
- * @param pkg the package to add
- * @return 0 on success, -1 on error (pm_errno is set accordingly)
- */
-int SYMEXPORT alpm_add_pkg(pmpkg_t *pkg)
+/** Add a package to the transaction. */
+int SYMEXPORT alpm_add_pkg(alpm_handle_t *handle, alpm_pkg_t *pkg)
{
const char *pkgname, *pkgver;
- pmtrans_t *trans;
- pmdb_t *db_local;
- pmpkg_t *local;
-
- ALPM_LOG_FUNC;
+ alpm_trans_t *trans;
+ alpm_pkg_t *local;
/* Sanity checks */
- ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
+ ASSERT(pkg != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
+ ASSERT(handle == pkg->handle, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -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 != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
- db_local = handle->db_local;
+ ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
+ ASSERT(trans->state == STATE_INITIALIZED,
+ RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1));
- pkgname = alpm_pkg_get_name(pkg);
- pkgver = alpm_pkg_get_version(pkg);
+ pkgname = pkg->name;
+ pkgver = pkg->version;
- _alpm_log(PM_LOG_DEBUG, "adding package '%s'\n", pkgname);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "adding package '%s'\n", pkgname);
if(_alpm_pkg_find(trans->add, pkgname)) {
- RET_ERR(PM_ERR_TRANS_DUP_TARGET, -1);
+ RET_ERR(handle, ALPM_ERR_TRANS_DUP_TARGET, -1);
}
- local = _alpm_db_get_pkgfromcache(db_local, pkgname);
+ local = _alpm_db_get_pkgfromcache(handle->db_local, pkgname);
if(local) {
const char *localpkgname = alpm_pkg_get_name(local);
const char *localpkgver = alpm_pkg_get_version(local);
int cmp = _alpm_pkg_compare_versions(pkg, local);
if(cmp == 0) {
- if(trans->flags & PM_TRANS_FLAG_NEEDED) {
+ if(trans->flags & ALPM_TRANS_FLAG_NEEDED) {
/* with the NEEDED flag, packages up to date are not reinstalled */
- _alpm_log(PM_LOG_WARNING, _("%s-%s is up to date -- skipping\n"),
+ _alpm_log(handle, ALPM_LOG_WARNING, _("%s-%s is up to date -- skipping\n"),
localpkgname, localpkgver);
- return(0);
- } else if(!(trans->flags & PM_TRANS_FLAG_DOWNLOADONLY)) {
- _alpm_log(PM_LOG_WARNING, _("%s-%s is up to date -- reinstalling\n"),
+ return 0;
+ } else if(!(trans->flags & ALPM_TRANS_FLAG_DOWNLOADONLY)) {
+ _alpm_log(handle, ALPM_LOG_WARNING, _("%s-%s is up to date -- reinstalling\n"),
localpkgname, localpkgver);
}
} else if(cmp < 0) {
/* local version is newer */
- _alpm_log(PM_LOG_WARNING, _("downgrading package %s (%s => %s)\n"),
+ _alpm_log(handle, ALPM_LOG_WARNING, _("downgrading package %s (%s => %s)\n"),
localpkgname, localpkgver, pkgver);
}
}
/* add the package to the transaction */
- pkg->reason = PM_PKG_REASON_EXPLICIT;
- _alpm_log(PM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
+ pkg->reason = ALPM_PKG_REASON_EXPLICIT;
+ _alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s-%s to the transaction add list\n",
pkgname, pkgver);
trans->add = alpm_list_add(trans->add, pkg);
- return(0);
+ return 0;
}
-static int perform_extraction(struct archive *archive,
+static int perform_extraction(alpm_handle_t *handle, struct archive *archive,
struct archive_entry *entry, const char *filename, const char *origname)
{
int ret;
@@ -125,27 +119,26 @@ static int perform_extraction(struct archive *archive,
ret = archive_read_extract(archive, entry, archive_flags);
if(ret == ARCHIVE_WARN && archive_errno(archive) != ENOSPC) {
/* operation succeeded but a "non-critical" error was encountered */
- _alpm_log(PM_LOG_WARNING, _("warning given when extracting %s (%s)\n"),
+ _alpm_log(handle, ALPM_LOG_WARNING, _("warning given when extracting %s (%s)\n"),
origname, archive_error_string(archive));
} else if(ret != ARCHIVE_OK) {
- _alpm_log(PM_LOG_ERROR, _("could not extract %s (%s)\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not extract %s (%s)\n"),
origname, archive_error_string(archive));
- alpm_logaction("error: could not extract %s (%s)\n",
+ alpm_logaction(handle, "error: could not extract %s (%s)\n",
origname, archive_error_string(archive));
- return(1);
+ return 1;
}
- return(0);
+ return 0;
}
-static int extract_single_file(struct archive *archive,
- struct archive_entry *entry, pmpkg_t *newpkg, pmpkg_t *oldpkg,
- pmtrans_t *trans, pmdb_t *db)
+static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
+ struct archive_entry *entry, alpm_pkg_t *newpkg, alpm_pkg_t *oldpkg)
{
const char *entryname;
mode_t entrymode;
char filename[PATH_MAX]; /* the actual file we're extracting */
int needbackup = 0, notouch = 0;
- char *hash_orig = NULL;
+ const char *hash_orig = NULL;
char *entryname_orig = NULL;
int errors = 0;
@@ -157,19 +150,19 @@ static int extract_single_file(struct archive *archive,
if(strcmp(entryname, ".INSTALL") == 0) {
/* the install script goes inside the db */
snprintf(filename, PATH_MAX, "%s%s-%s/install",
- _alpm_db_path(db), newpkg->name, newpkg->version);
+ _alpm_db_path(handle->db_local), newpkg->name, newpkg->version);
archive_entry_set_perm(entry, 0644);
} else if(strcmp(entryname, ".CHANGELOG") == 0) {
/* the changelog goes inside the db */
snprintf(filename, PATH_MAX, "%s%s-%s/changelog",
- _alpm_db_path(db), newpkg->name, newpkg->version);
+ _alpm_db_path(handle->db_local), newpkg->name, newpkg->version);
archive_entry_set_perm(entry, 0644);
} else if(*entryname == '.') {
/* for now, ignore all files starting with '.' that haven't
* already been handled (for future possibilities) */
- _alpm_log(PM_LOG_DEBUG, "skipping extraction of '%s'\n", entryname);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "skipping extraction of '%s'\n", entryname);
archive_read_data_skip(archive);
- return(0);
+ return 0;
} else {
/* build the new entryname relative to handle->root */
snprintf(filename, PATH_MAX, "%s%s", handle->root, entryname);
@@ -177,12 +170,12 @@ static int extract_single_file(struct archive *archive,
/* if a file is in NoExtract then we never extract it */
if(alpm_list_find_str(handle->noextract, entryname)) {
- _alpm_log(PM_LOG_DEBUG, "%s is in NoExtract, skipping extraction\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "%s is in NoExtract, skipping extraction\n",
entryname);
- alpm_logaction("note: %s is in NoExtract, skipping extraction\n",
+ alpm_logaction(handle, "note: %s is in NoExtract, skipping extraction\n",
entryname);
archive_read_data_skip(archive);
- return(0);
+ return 0;
}
/* Check for file existence. This is one of the more crucial parts
@@ -216,42 +209,42 @@ static int extract_single_file(struct archive *archive,
if(lsbuf.st_mode != entrymode) {
/* if filesystem perms are different than pkg perms, warn user */
mode_t mask = 07777;
- _alpm_log(PM_LOG_WARNING, _("directory permissions differ on %s\n"
+ _alpm_log(handle, ALPM_LOG_WARNING, _("directory permissions differ on %s\n"
"filesystem: %o package: %o\n"), entryname, lsbuf.st_mode & mask,
entrymode & mask);
- alpm_logaction("warning: directory permissions differ on %s\n"
+ alpm_logaction(handle, "warning: directory permissions differ on %s\n"
"filesystem: %o package: %o\n", entryname, lsbuf.st_mode & mask,
entrymode & mask);
}
- _alpm_log(PM_LOG_DEBUG, "extract: skipping dir extraction of %s\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "extract: skipping dir extraction of %s\n",
entryname);
archive_read_data_skip(archive);
- return(0);
+ return 0;
} else {
/* case 10/11: trying to overwrite dir with file/symlink, don't allow it */
- _alpm_log(PM_LOG_ERROR, _("extract: not overwriting dir with file %s\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("extract: not overwriting dir with file %s\n"),
entryname);
archive_read_data_skip(archive);
- return(1);
+ return 1;
}
} else if(S_ISLNK(lsbuf.st_mode) && S_ISDIR(entrymode)) {
/* case 9: existing symlink, dir in package */
if(S_ISDIR(sbuf.st_mode)) {
/* the symlink on FS is to a directory, so we'll use it */
- _alpm_log(PM_LOG_DEBUG, "extract: skipping symlink overwrite of %s\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "extract: skipping symlink overwrite of %s\n",
entryname);
archive_read_data_skip(archive);
- return(0);
+ return 0;
} else {
/* this is BAD. symlink was not to a directory */
- _alpm_log(PM_LOG_ERROR, _("extract: symlink %s does not point to dir\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("extract: symlink %s does not point to dir\n"),
entryname);
archive_read_data_skip(archive);
- return(1);
+ return 1;
}
} else if(S_ISREG(lsbuf.st_mode) && S_ISDIR(entrymode)) {
/* case 6: trying to overwrite file with dir */
- _alpm_log(PM_LOG_DEBUG, "extract: overwriting file with dir %s\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "extract: overwriting file with dir %s\n",
entryname);
} else if(S_ISREG(entrymode)) {
/* case 4,7: */
@@ -259,24 +252,24 @@ static int extract_single_file(struct archive *archive,
if(alpm_list_find_str(handle->noupgrade, entryname)) {
notouch = 1;
} else {
+ alpm_backup_t *backup;
/* go to the backup array and see if our conflict is there */
/* check newpkg first, so that adding backup files is retroactive */
- if(alpm_list_find_str(alpm_pkg_get_backup(newpkg), entryname) != NULL) {
+ backup = _alpm_needbackup(entryname, newpkg);
+ if(backup) {
+ /* if we force hash_orig to be non-NULL retroactive backup works */
+ hash_orig = "";
needbackup = 1;
}
/* check oldpkg for a backup entry, store the hash if available */
if(oldpkg) {
- hash_orig = _alpm_needbackup(entryname, alpm_pkg_get_backup(oldpkg));
- if(hash_orig) {
+ backup = _alpm_needbackup(entryname, oldpkg);
+ if(backup) {
+ hash_orig = backup->hash;
needbackup = 1;
}
}
-
- /* if we force hash_orig to be non-NULL retroactive backup works */
- if(needbackup && !hash_orig) {
- STRDUP(hash_orig, "", RET_ERR(PM_ERR_MEMORY, -1));
- }
}
}
/* else if(S_ISLNK(entrymode)) */
@@ -285,7 +278,7 @@ static int extract_single_file(struct archive *archive,
/* we need access to the original entryname later after calls to
* archive_entry_set_pathname(), so we need to dupe it and free() later */
- STRDUP(entryname_orig, entryname, RET_ERR(PM_ERR_MEMORY, -1));
+ STRDUP(entryname_orig, entryname, RET_ERR(handle, ALPM_ERR_MEMORY, -1));
if(needbackup) {
char checkfile[PATH_MAX];
@@ -294,44 +287,36 @@ static int extract_single_file(struct archive *archive,
snprintf(checkfile, PATH_MAX, "%s.paccheck", filename);
- ret = perform_extraction(archive, entry, checkfile, entryname_orig);
+ ret = perform_extraction(handle, archive, entry, checkfile, entryname_orig);
if(ret == 1) {
/* error */
- FREE(hash_orig);
FREE(entryname_orig);
- return(1);
+ return 1;
}
hash_local = alpm_compute_md5sum(filename);
hash_pkg = alpm_compute_md5sum(checkfile);
- /* append the new md5 hash to it's respective entry
- * in newpkg's backup (it will be the new orginal) */
- alpm_list_t *backups;
- for(backups = alpm_pkg_get_backup(newpkg); backups;
- backups = alpm_list_next(backups)) {
- char *oldbackup = alpm_list_getdata(backups);
- if(!oldbackup || strcmp(oldbackup, entryname_orig) != 0) {
+ /* update the md5 hash in newpkg's backup (it will be the new orginal) */
+ alpm_list_t *i;
+ for(i = alpm_pkg_get_backup(newpkg); i; i = i->next) {
+ alpm_backup_t *backup = i->data;
+ char *newhash;
+ if(!backup->name || strcmp(backup->name, entryname_orig) != 0) {
continue;
}
- char *backup = NULL;
- /* length is tab char, null byte and MD5 (32 char) */
- size_t backup_len = strlen(oldbackup) + 34;
- MALLOC(backup, backup_len, RET_ERR(PM_ERR_MEMORY, -1));
-
- sprintf(backup, "%s\t%s", oldbackup, hash_pkg);
- backup[backup_len-1] = '\0';
- FREE(oldbackup);
- backups->data = backup;
+ STRDUP(newhash, hash_pkg, RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+ FREE(backup->hash);
+ backup->hash = newhash;
}
- _alpm_log(PM_LOG_DEBUG, "checking hashes for %s\n", entryname_orig);
- _alpm_log(PM_LOG_DEBUG, "current: %s\n", hash_local);
- _alpm_log(PM_LOG_DEBUG, "new: %s\n", hash_pkg);
- _alpm_log(PM_LOG_DEBUG, "original: %s\n", hash_orig);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "checking hashes for %s\n", entryname_orig);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "current: %s\n", hash_local);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "new: %s\n", hash_pkg);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "original: %s\n", hash_orig);
if(!oldpkg) {
- if(strcmp(hash_local, hash_pkg) != 0) {
+ if(hash_local && hash_pkg && strcmp(hash_local, hash_pkg) != 0) {
/* looks like we have a local file that has a different hash as the
* file in the package, move it to a .pacorig */
char newpath[PATH_MAX];
@@ -339,22 +324,22 @@ static int extract_single_file(struct archive *archive,
/* move the existing file to the "pacorig" */
if(rename(filename, newpath)) {
- _alpm_log(PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
filename, newpath, strerror(errno));
- alpm_logaction("error: could not rename %s to %s (%s)\n",
+ alpm_logaction(handle, "error: could not rename %s to %s (%s)\n",
filename, newpath, strerror(errno));
errors++;
} else {
/* rename the file we extracted to the real name */
if(rename(checkfile, filename)) {
- _alpm_log(PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
checkfile, filename, strerror(errno));
- alpm_logaction("error: could not rename %s to %s (%s)\n",
+ alpm_logaction(handle, "error: could not rename %s to %s (%s)\n",
checkfile, filename, strerror(errno));
errors++;
} else {
- _alpm_log(PM_LOG_WARNING, _("%s saved as %s\n"), filename, newpath);
- alpm_logaction("warning: %s saved as %s\n", filename, newpath);
+ _alpm_log(handle, ALPM_LOG_WARNING, _("%s saved as %s\n"), filename, newpath);
+ alpm_logaction(handle, "warning: %s saved as %s\n", filename, newpath);
}
}
} else {
@@ -364,51 +349,51 @@ static int extract_single_file(struct archive *archive,
} else if(hash_orig) {
/* the fun part */
- if(strcmp(hash_orig, hash_local) == 0) {
+ if(hash_local && strcmp(hash_orig, hash_local) == 0) {
/* installed file has NOT been changed by user */
- if(strcmp(hash_orig, hash_pkg) != 0) {
- _alpm_log(PM_LOG_DEBUG, "action: installing new file: %s\n",
+ if(hash_pkg && strcmp(hash_orig, hash_pkg) != 0) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "action: installing new file: %s\n",
entryname_orig);
if(rename(checkfile, filename)) {
- _alpm_log(PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
checkfile, filename, strerror(errno));
- alpm_logaction("error: could not rename %s to %s (%s)\n",
+ alpm_logaction(handle, "error: could not rename %s to %s (%s)\n",
checkfile, filename, strerror(errno));
errors++;
}
} else {
- /* there's no sense in installing the same file twice, install
- * ONLY is the original and package hashes differ */
- _alpm_log(PM_LOG_DEBUG, "action: leaving existing file in place\n");
+ /* no sense in installing the same file twice, install
+ * ONLY if the original and package hashes differ */
+ _alpm_log(handle, ALPM_LOG_DEBUG, "action: leaving existing file in place\n");
unlink(checkfile);
}
- } else if(strcmp(hash_orig, hash_pkg) == 0) {
+ } else if(hash_pkg && strcmp(hash_orig, hash_pkg) == 0) {
/* originally installed file and new file are the same - this
* implies the case above failed - i.e. the file was changed by a
* user */
- _alpm_log(PM_LOG_DEBUG, "action: leaving existing file in place\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "action: leaving existing file in place\n");
unlink(checkfile);
- } else if(strcmp(hash_local, hash_pkg) == 0) {
+ } else if(hash_local && hash_pkg && strcmp(hash_local, hash_pkg) == 0) {
/* this would be magical. The above two cases failed, but the
* user changes just so happened to make the new file exactly the
* same as the one in the package... skip it */
- _alpm_log(PM_LOG_DEBUG, "action: leaving existing file in place\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "action: leaving existing file in place\n");
unlink(checkfile);
} else {
char newpath[PATH_MAX];
- _alpm_log(PM_LOG_DEBUG, "action: keeping current file and installing"
+ _alpm_log(handle, ALPM_LOG_DEBUG, "action: keeping current file and installing"
" new one with .pacnew ending\n");
snprintf(newpath, PATH_MAX, "%s.pacnew", filename);
if(rename(checkfile, newpath)) {
- _alpm_log(PM_LOG_ERROR, _("could not install %s as %s (%s)\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not install %s as %s (%s)\n"),
filename, newpath, strerror(errno));
- alpm_logaction("error: could not install %s as %s (%s)\n",
+ alpm_logaction(handle, "error: could not install %s as %s (%s)\n",
filename, newpath, strerror(errno));
} else {
- _alpm_log(PM_LOG_WARNING, _("%s installed as %s\n"),
+ _alpm_log(handle, ALPM_LOG_WARNING, _("%s installed as %s\n"),
filename, newpath);
- alpm_logaction("warning: %s installed as %s\n",
+ alpm_logaction(handle, "warning: %s installed as %s\n",
filename, newpath);
}
}
@@ -416,126 +401,113 @@ static int extract_single_file(struct archive *archive,
FREE(hash_local);
FREE(hash_pkg);
- FREE(hash_orig);
} else {
int ret;
/* we didn't need a backup */
if(notouch) {
/* change the path to a .pacnew extension */
- _alpm_log(PM_LOG_DEBUG, "%s is in NoUpgrade -- skipping\n", filename);
- _alpm_log(PM_LOG_WARNING, _("extracting %s as %s.pacnew\n"), filename, filename);
- alpm_logaction("warning: extracting %s as %s.pacnew\n", filename, filename);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "%s is in NoUpgrade -- skipping\n", filename);
+ _alpm_log(handle, ALPM_LOG_WARNING, _("extracting %s as %s.pacnew\n"), filename, filename);
+ alpm_logaction(handle, "warning: extracting %s as %s.pacnew\n", filename, filename);
strncat(filename, ".pacnew", PATH_MAX - strlen(filename));
} else {
- _alpm_log(PM_LOG_DEBUG, "extracting %s\n", filename);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "extracting %s\n", filename);
}
- if(trans->flags & PM_TRANS_FLAG_FORCE) {
+ if(handle->trans->flags & ALPM_TRANS_FLAG_FORCE) {
/* if FORCE was used, unlink() each file (whether it's there
* or not) before extracting. This prevents the old "Text file busy"
* error that crops up if forcing a glibc or pacman upgrade. */
unlink(filename);
}
- ret = perform_extraction(archive, entry, filename, entryname_orig);
+ ret = perform_extraction(handle, archive, entry, filename, entryname_orig);
if(ret == 1) {
/* error */
FREE(entryname_orig);
- return(1);
+ return 1;
}
/* calculate an hash if this is in newpkg's backup */
- alpm_list_t *b;
- for(b = alpm_pkg_get_backup(newpkg); b; b = b->next) {
- char *backup = NULL, *hash = NULL;
- char *oldbackup = alpm_list_getdata(b);
- /* length is tab char, null byte and MD5 (32 char) */
- size_t backup_len = strlen(oldbackup) + 34;
-
- if(!oldbackup || strcmp(oldbackup, entryname_orig) != 0) {
+ alpm_list_t *i;
+ for(i = alpm_pkg_get_backup(newpkg); i; i = i->next) {
+ alpm_backup_t *backup = i->data;
+ char *newhash;
+ if(!backup->name || strcmp(backup->name, entryname_orig) != 0) {
continue;
}
- _alpm_log(PM_LOG_DEBUG, "appending backup entry for %s\n", filename);
-
- hash = alpm_compute_md5sum(filename);
- MALLOC(backup, backup_len, RET_ERR(PM_ERR_MEMORY, -1));
-
- sprintf(backup, "%s\t%s", oldbackup, hash);
- backup[backup_len-1] = '\0';
- FREE(hash);
- FREE(oldbackup);
- b->data = backup;
+ _alpm_log(handle, ALPM_LOG_DEBUG, "appending backup entry for %s\n", entryname_orig);
+ newhash = alpm_compute_md5sum(filename);
+ FREE(backup->hash);
+ backup->hash = newhash;
}
}
FREE(entryname_orig);
- return(errors);
+ return errors;
}
-static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
- size_t pkg_count, pmtrans_t *trans, pmdb_t *db)
+static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
+ size_t pkg_current, size_t pkg_count)
{
int i, ret = 0, errors = 0;
- char scriptlet[PATH_MAX+1];
+ char scriptlet[PATH_MAX];
int is_upgrade = 0;
- pmpkg_t *oldpkg = NULL;
-
- ALPM_LOG_FUNC;
+ alpm_pkg_t *oldpkg = NULL;
+ alpm_db_t *db = handle->db_local;
+ alpm_trans_t *trans = handle->trans;
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
+ ASSERT(trans != NULL, return -1);
snprintf(scriptlet, PATH_MAX, "%s%s-%s/install",
_alpm_db_path(db), alpm_pkg_get_name(newpkg),
alpm_pkg_get_version(newpkg));
/* see if this is an upgrade. if so, remove the old package first */
- pmpkg_t *local = _alpm_db_get_pkgfromcache(db, newpkg->name);
+ alpm_pkg_t *local = _alpm_db_get_pkgfromcache(db, newpkg->name);
if(local) {
is_upgrade = 1;
/* we'll need to save some record for backup checks later */
oldpkg = _alpm_pkg_dup(local);
- /* make sure all infos are loaded because the database entry
- * will be removed soon */
- _alpm_local_db_read(oldpkg->origin_data.db, oldpkg, INFRQ_ALL);
- EVENT(trans, PM_TRANS_EVT_UPGRADE_START, newpkg, oldpkg);
- _alpm_log(PM_LOG_DEBUG, "upgrading package %s-%s\n",
+ EVENT(trans, ALPM_TRANS_EVT_UPGRADE_START, newpkg, oldpkg);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "upgrading package %s-%s\n",
newpkg->name, newpkg->version);
/* copy over the install reason */
newpkg->reason = alpm_pkg_get_reason(oldpkg);
/* pre_upgrade scriptlet */
- if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
- _alpm_runscriptlet(handle->root, newpkg->origin_data.file,
- "pre_upgrade", newpkg->version, oldpkg->version, trans);
+ if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
+ _alpm_runscriptlet(handle, newpkg->origin_data.file,
+ "pre_upgrade", newpkg->version, oldpkg->version);
}
} else {
is_upgrade = 0;
- EVENT(trans, PM_TRANS_EVT_ADD_START, newpkg, NULL);
- _alpm_log(PM_LOG_DEBUG, "adding package %s-%s\n",
+ EVENT(trans, ALPM_TRANS_EVT_ADD_START, newpkg, NULL);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s-%s\n",
newpkg->name, newpkg->version);
/* pre_install scriptlet */
- if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
- _alpm_runscriptlet(handle->root, newpkg->origin_data.file,
- "pre_install", newpkg->version, NULL, trans);
+ if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
+ _alpm_runscriptlet(handle, newpkg->origin_data.file,
+ "pre_install", newpkg->version, NULL);
}
}
/* we override any pre-set reason if we have alldeps or allexplicit set */
- if(trans->flags & PM_TRANS_FLAG_ALLDEPS) {
- newpkg->reason = PM_PKG_REASON_DEPEND;
- } else if(trans->flags & PM_TRANS_FLAG_ALLEXPLICIT) {
- newpkg->reason = PM_PKG_REASON_EXPLICIT;
+ if(trans->flags & ALPM_TRANS_FLAG_ALLDEPS) {
+ newpkg->reason = ALPM_PKG_REASON_DEPEND;
+ } else if(trans->flags & ALPM_TRANS_FLAG_ALLEXPLICIT) {
+ newpkg->reason = ALPM_PKG_REASON_EXPLICIT;
}
if(oldpkg) {
/* set up fake remove transaction */
- if(_alpm_upgraderemove_package(oldpkg, newpkg, trans) == -1) {
- pm_errno = PM_ERR_TRANS_ABORT;
+ if(_alpm_remove_single_package(handle, oldpkg, newpkg, 0, 0) == -1) {
+ handle->pm_errno = ALPM_ERR_TRANS_ABORT;
ret = -1;
goto cleanup;
}
@@ -544,23 +516,23 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
/* prepare directory for database entries so permission are correct after
changelog/install script installation (FS#12263) */
if(_alpm_local_db_prepare(db, newpkg)) {
- alpm_logaction("error: could not create database entry %s-%s\n",
+ alpm_logaction(handle, "error: could not create database entry %s-%s\n",
alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
- pm_errno = PM_ERR_DB_WRITE;
+ handle->pm_errno = ALPM_ERR_DB_WRITE;
ret = -1;
goto cleanup;
}
- if(!(trans->flags & PM_TRANS_FLAG_DBONLY)) {
+ if(!(trans->flags & ALPM_TRANS_FLAG_DBONLY)) {
struct archive *archive;
struct archive_entry *entry;
char cwd[PATH_MAX] = "";
int restore_cwd = 0;
- _alpm_log(PM_LOG_DEBUG, "extracting files\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "extracting files\n");
- if ((archive = archive_read_new()) == NULL) {
- pm_errno = PM_ERR_LIBARCHIVE;
+ if((archive = archive_read_new()) == NULL) {
+ handle->pm_errno = ALPM_ERR_LIBARCHIVE;
ret = -1;
goto cleanup;
}
@@ -568,34 +540,35 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
archive_read_support_compression_all(archive);
archive_read_support_format_all(archive);
- _alpm_log(PM_LOG_DEBUG, "archive: %s\n", newpkg->origin_data.file);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "archive: %s\n", newpkg->origin_data.file);
if(archive_read_open_filename(archive, newpkg->origin_data.file,
ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
- pm_errno = PM_ERR_PKG_OPEN;
+ handle->pm_errno = ALPM_ERR_PKG_OPEN;
ret = -1;
goto cleanup;
}
/* save the cwd so we can restore it later */
if(getcwd(cwd, PATH_MAX) == NULL) {
- _alpm_log(PM_LOG_ERROR, _("could not get current working directory\n"));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not get current working directory\n"));
} else {
restore_cwd = 1;
}
/* libarchive requires this for extracting hard links */
if(chdir(handle->root) != 0) {
- _alpm_log(PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), handle->root, strerror(errno));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
+ handle->root, strerror(errno));
ret = -1;
goto cleanup;
}
/* call PROGRESS once with 0 percent, as we sort-of skip that here */
if(is_upgrade) {
- PROGRESS(trans, PM_TRANS_PROGRESS_UPGRADE_START,
+ PROGRESS(trans, ALPM_TRANS_PROGRESS_UPGRADE_START,
alpm_pkg_get_name(newpkg), 0, pkg_count, pkg_current);
} else {
- PROGRESS(trans, PM_TRANS_PROGRESS_ADD_START,
+ PROGRESS(trans, ALPM_TRANS_PROGRESS_ADD_START,
alpm_pkg_get_name(newpkg), 0, pkg_count, pkg_current);
}
@@ -608,7 +581,7 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
* (missing metadata sizes) */
int64_t pos = archive_position_compressed(archive);
percent = (pos * 100) / newpkg->size;
- _alpm_log(PM_LOG_DEBUG, "decompression progress: "
+ _alpm_log(handle, ALPM_LOG_DEBUG, "decompression progress: "
"%d%% (%"PRId64" / %jd)\n",
percent, pos, (intmax_t)newpkg->size);
if(percent >= 100) {
@@ -619,37 +592,36 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
}
if(is_upgrade) {
- PROGRESS(trans, PM_TRANS_PROGRESS_UPGRADE_START,
+ PROGRESS(trans, ALPM_TRANS_PROGRESS_UPGRADE_START,
alpm_pkg_get_name(newpkg), percent, pkg_count,
pkg_current);
} else {
- PROGRESS(trans, PM_TRANS_PROGRESS_ADD_START,
+ PROGRESS(trans, ALPM_TRANS_PROGRESS_ADD_START,
alpm_pkg_get_name(newpkg), percent, pkg_count,
pkg_current);
}
/* extract the next file from the archive */
- errors += extract_single_file(archive, entry, newpkg, oldpkg,
- trans, db);
+ errors += extract_single_file(handle, archive, entry, newpkg, oldpkg);
}
archive_read_finish(archive);
/* restore the old cwd if we have it */
if(restore_cwd && chdir(cwd) != 0) {
- _alpm_log(PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
}
if(errors) {
ret = -1;
if(is_upgrade) {
- _alpm_log(PM_LOG_ERROR, _("problem occurred while upgrading %s\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("problem occurred while upgrading %s\n"),
newpkg->name);
- alpm_logaction("error: problem occurred while upgrading %s\n",
+ alpm_logaction(handle, "error: problem occurred while upgrading %s\n",
newpkg->name);
} else {
- _alpm_log(PM_LOG_ERROR, _("problem occurred while installing %s\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("problem occurred while installing %s\n"),
newpkg->name);
- alpm_logaction("error: problem occurred while installing %s\n",
+ alpm_logaction(handle, "error: problem occurred while installing %s\n",
newpkg->name);
}
}
@@ -658,69 +630,65 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
/* make an install date (in UTC) */
newpkg->installdate = time(NULL);
- _alpm_log(PM_LOG_DEBUG, "updating database\n");
- _alpm_log(PM_LOG_DEBUG, "adding database entry '%s'\n", newpkg->name);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "updating database\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "adding database entry '%s'\n", newpkg->name);
if(_alpm_local_db_write(db, newpkg, INFRQ_ALL)) {
- _alpm_log(PM_LOG_ERROR, _("could not update database entry %s-%s\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not update database entry %s-%s\n"),
alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
- alpm_logaction("error: could not update database entry %s-%s\n",
+ alpm_logaction(handle, "error: could not update database entry %s-%s\n",
alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
- pm_errno = PM_ERR_DB_WRITE;
+ handle->pm_errno = ALPM_ERR_DB_WRITE;
ret = -1;
goto cleanup;
}
if(_alpm_db_add_pkgincache(db, newpkg) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not add entry '%s' in cache\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not add entry '%s' in cache\n"),
alpm_pkg_get_name(newpkg));
}
if(is_upgrade) {
- PROGRESS(trans, PM_TRANS_PROGRESS_UPGRADE_START,
+ PROGRESS(trans, ALPM_TRANS_PROGRESS_UPGRADE_START,
alpm_pkg_get_name(newpkg), 100, pkg_count, pkg_current);
} else {
- PROGRESS(trans, PM_TRANS_PROGRESS_ADD_START,
+ PROGRESS(trans, ALPM_TRANS_PROGRESS_ADD_START,
alpm_pkg_get_name(newpkg), 100, pkg_count, pkg_current);
}
/* run the post-install script if it exists */
if(alpm_pkg_has_scriptlet(newpkg)
- && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
+ && !(trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
if(is_upgrade) {
- _alpm_runscriptlet(handle->root, scriptlet, "post_upgrade",
+ _alpm_runscriptlet(handle, scriptlet, "post_upgrade",
alpm_pkg_get_version(newpkg),
- oldpkg ? alpm_pkg_get_version(oldpkg) : NULL, trans);
+ oldpkg ? alpm_pkg_get_version(oldpkg) : NULL);
} else {
- _alpm_runscriptlet(handle->root, scriptlet, "post_install",
- alpm_pkg_get_version(newpkg), NULL, trans);
+ _alpm_runscriptlet(handle, scriptlet, "post_install",
+ alpm_pkg_get_version(newpkg), NULL);
}
}
if(is_upgrade) {
- EVENT(trans, PM_TRANS_EVT_UPGRADE_DONE, newpkg, oldpkg);
+ EVENT(trans, ALPM_TRANS_EVT_UPGRADE_DONE, newpkg, oldpkg);
} else {
- EVENT(trans, PM_TRANS_EVT_ADD_DONE, newpkg, oldpkg);
+ EVENT(trans, ALPM_TRANS_EVT_ADD_DONE, newpkg, oldpkg);
}
cleanup:
_alpm_pkg_free(oldpkg);
- return(ret);
+ return ret;
}
-int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
+int _alpm_upgrade_packages(alpm_handle_t *handle)
{
size_t pkg_count, pkg_current;
int skip_ldconfig = 0, ret = 0;
alpm_list_t *targ;
-
- ALPM_LOG_FUNC;
-
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
- ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
+ alpm_trans_t *trans = handle->trans;
if(trans->add == NULL) {
- return(0);
+ return 0;
}
pkg_count = alpm_list_count(trans->add);
@@ -728,15 +696,16 @@ int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
/* loop through our package list adding/upgrading one at a time */
for(targ = trans->add; targ; targ = targ->next) {
+ alpm_pkg_t *newpkg = targ->data;
+
if(handle->trans->state == STATE_INTERRUPTED) {
- return(ret);
+ return ret;
}
- pmpkg_t *newpkg = (pmpkg_t *)targ->data;
- if(commit_single_pkg(newpkg, pkg_current, pkg_count, trans, db)) {
+ if(commit_single_pkg(handle, newpkg, pkg_current, pkg_count)) {
/* something screwed up on the commit, abort the trans */
trans->state = STATE_INTERRUPTED;
- pm_errno = PM_ERR_TRANS_ABORT;
+ handle->pm_errno = ALPM_ERR_TRANS_ABORT;
/* running ldconfig at this point could possibly screw system */
skip_ldconfig = 1;
ret = -1;
@@ -747,10 +716,10 @@ int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
if(!skip_ldconfig) {
/* run ldconfig if it exists */
- _alpm_ldconfig(handle->root);
+ _alpm_ldconfig(handle);
}
- return(ret);
+ return ret;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/add.h b/lib/libalpm/add.h
index afc7be26..77a3d22a 100644
--- a/lib/libalpm/add.h
+++ b/lib/libalpm/add.h
@@ -24,7 +24,7 @@
#include "alpm_list.h"
#include "trans.h"
-int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db);
+int _alpm_upgrade_packages(alpm_handle_t *handle);
#endif /* _ALPM_ADD_H */
diff --git a/lib/libalpm/alpm.c b/lib/libalpm/alpm.c
index a60a4bb6..585c6a82 100644
--- a/lib/libalpm/alpm.c
+++ b/lib/libalpm/alpm.c
@@ -23,20 +23,17 @@
#include "config.h"
-/* connection caching setup */
-#ifdef HAVE_LIBFETCH
-#include <fetch.h>
+#ifdef HAVE_LIBCURL
+#include <curl/curl.h>
#endif
/* libalpm */
#include "alpm.h"
#include "alpm_list.h"
#include "handle.h"
+#include "log.h"
#include "util.h"
-/* Globals */
-enum _pmerrno_t pm_errno SYMEXPORT;
-
/** \addtogroup alpm_interface Interface Functions
* @brief Functions to initialize and release libalpm
* @{
@@ -44,64 +41,90 @@ enum _pmerrno_t pm_errno SYMEXPORT;
/** Initializes the library. This must be called before any other
* functions are called.
- * @return 0 on success, -1 on error (pm_errno is set accordingly)
+ * @param root the root path for all filesystem operations
+ * @param dbpath the absolute path to the libalpm database
+ * @param err an optional variable to hold any error return codes
+ * @return a context handle on success, NULL on error, err will be set if provided
*/
-int SYMEXPORT alpm_initialize(void)
+alpm_handle_t SYMEXPORT *alpm_initialize(const char *root, const char *dbpath,
+ enum _alpm_errno_t *err)
{
- ASSERT(handle == NULL, RET_ERR(PM_ERR_HANDLE_NOT_NULL, -1));
-
- handle = _alpm_handle_new();
- if(handle == NULL) {
- RET_ERR(PM_ERR_MEMORY, -1);
+ enum _alpm_errno_t myerr;
+ const char *lf = "db.lck";
+ size_t lockfilelen;
+ alpm_handle_t *myhandle = _alpm_handle_new();
+
+ if(myhandle == NULL) {
+ myerr = ALPM_ERR_MEMORY;
+ goto cleanup;
+ }
+ if((myerr = _alpm_set_directory_option(root, &(myhandle->root), 1))) {
+ goto cleanup;
}
- if(_alpm_db_register_local() == NULL) {
- /* error code should be set */
- _alpm_handle_free(handle);
- handle = NULL;
- return(-1);
+ if((myerr = _alpm_set_directory_option(dbpath, &(myhandle->dbpath), 1))) {
+ goto cleanup;
+ }
+
+ lockfilelen = strlen(myhandle->dbpath) + strlen(lf) + 1;
+ myhandle->lockfile = calloc(lockfilelen, sizeof(char));
+ snprintf(myhandle->lockfile, lockfilelen, "%s%s", myhandle->dbpath, lf);
+
+ if(_alpm_db_register_local(myhandle) == NULL) {
+ myerr = myhandle->pm_errno;
+ goto cleanup;
}
#ifdef ENABLE_NLS
bindtextdomain("libalpm", LOCALEDIR);
#endif
-#ifdef HAVE_LIBFETCH
- fetchConnectionCacheInit(5, 1);
+#ifdef HAVE_LIBCURL
+ curl_global_init(CURL_GLOBAL_SSL);
+ myhandle->curl = curl_easy_init();
#endif
- return(0);
+ return myhandle;
+
+cleanup:
+ _alpm_handle_free(myhandle);
+ if(err && myerr) {
+ *err = myerr;
+ }
+ return NULL;
}
/** Release the library. This should be the last alpm call you make.
- * @return 0 on success, -1 on error (pm_errno is set accordingly)
+ * After this returns, handle should be considered invalid and cannot be reused
+ * in any way.
+ * @param handle the context handle
+ * @return 0 on success, -1 on error
*/
-int SYMEXPORT alpm_release(void)
+int SYMEXPORT alpm_release(alpm_handle_t *myhandle)
{
- pmdb_t *db;
-
- ALPM_LOG_FUNC;
+ int ret = 0;
+ alpm_db_t *db;
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ CHECK_HANDLE(myhandle, return -1);
/* close local database */
- db = handle->db_local;
+ db = myhandle->db_local;
if(db) {
db->ops->unregister(db);
- handle->db_local = NULL;
+ myhandle->db_local = NULL;
}
- if(alpm_db_unregister_all() == -1) {
- return(-1);
+ if(alpm_db_unregister_all(myhandle) == -1) {
+ ret = -1;
}
- _alpm_handle_free(handle);
- handle = NULL;
+ _alpm_handle_unlock(myhandle);
+ _alpm_handle_free(myhandle);
-#ifdef HAVE_LIBFETCH
- fetchConnectionCacheClose();
+#ifdef HAVE_LIBCURL
+ curl_global_cleanup();
#endif
- return(0);
+ return ret;
}
/** @} */
@@ -112,7 +135,7 @@ int SYMEXPORT alpm_release(void)
/* Get the version of library */
const char SYMEXPORT *alpm_version(void) {
- return(LIB_VERSION);
+ return LIB_VERSION;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/alpm.h b/lib/libalpm/alpm.h
index cb643d29..a91b00f0 100644
--- a/lib/libalpm/alpm.h
+++ b/lib/libalpm/alpm.h
@@ -45,49 +45,209 @@ extern "C" {
*/
/*
- * Structures
+ * Enumerations
+ * These ones are used in multiple contexts, so are forward-declared.
+ */
+
+/**
+ * Install reasons.
+ * Why the package was installed.
*/
+typedef enum _alpm_pkgreason_t {
+ /** Explicitly requested by the user. */
+ ALPM_PKG_REASON_EXPLICIT = 0,
+ /** Installed as a dependency for another package. */
+ ALPM_PKG_REASON_DEPEND = 1
+} alpm_pkgreason_t;
-typedef struct __pmdb_t pmdb_t;
-typedef struct __pmpkg_t pmpkg_t;
-typedef struct __pmdelta_t pmdelta_t;
-typedef struct __pmgrp_t pmgrp_t;
-typedef struct __pmtrans_t pmtrans_t;
-typedef struct __pmdepend_t pmdepend_t;
-typedef struct __pmdepmissing_t pmdepmissing_t;
-typedef struct __pmconflict_t pmconflict_t;
-typedef struct __pmfileconflict_t pmfileconflict_t;
+/** Types of version constraints in dependency specs. */
+typedef enum _alpm_depmod_t {
+ /** No version constraint */
+ ALPM_DEP_MOD_ANY = 1,
+ /** Test version equality (package=x.y.z) */
+ ALPM_DEP_MOD_EQ,
+ /** Test for at least a version (package>=x.y.z) */
+ ALPM_DEP_MOD_GE,
+ /** Test for at most a version (package<=x.y.z) */
+ ALPM_DEP_MOD_LE,
+ /** Test for greater than some version (package>x.y.z) */
+ ALPM_DEP_MOD_GT,
+ /** Test for less than some version (package<x.y.z) */
+ ALPM_DEP_MOD_LT
+} alpm_depmod_t;
+
+/**
+ * File conflict type.
+ * Whether the conflict results from a file existing on the filesystem, or with
+ * another target in the transaction.
+ */
+typedef enum _alpm_fileconflicttype_t {
+ ALPM_FILECONFLICT_TARGET = 1,
+ ALPM_FILECONFLICT_FILESYSTEM
+} alpm_fileconflicttype_t;
+
+/**
+ * PGP signature verification options
+ */
+typedef enum _alpm_siglevel_t {
+ ALPM_SIG_PACKAGE = (1 << 0),
+ ALPM_SIG_PACKAGE_OPTIONAL = (1 << 1),
+ ALPM_SIG_PACKAGE_MARGINAL_OK = (1 << 2),
+ ALPM_SIG_PACKAGE_UNKNOWN_OK = (1 << 3),
+
+ ALPM_SIG_DATABASE = (1 << 10),
+ ALPM_SIG_DATABASE_OPTIONAL = (1 << 11),
+ ALPM_SIG_DATABASE_MARGINAL_OK = (1 << 12),
+ ALPM_SIG_DATABASE_UNKNOWN_OK = (1 << 13),
+
+ ALPM_SIG_USE_DEFAULT = (1 << 31)
+} alpm_siglevel_t;
+
+/**
+ * PGP signature verification status return codes
+ */
+typedef enum _alpm_sigstatus_t {
+ ALPM_SIGSTATUS_VALID,
+ ALPM_SIGSTATUS_KEY_EXPIRED,
+ ALPM_SIGSTATUS_SIG_EXPIRED,
+ ALPM_SIGSTATUS_KEY_UNKNOWN,
+ ALPM_SIGSTATUS_INVALID
+} alpm_sigstatus_t;
+
+/**
+ * PGP signature verification status return codes
+ */
+typedef enum _alpm_sigvalidity_t {
+ ALPM_SIGVALIDITY_FULL,
+ ALPM_SIGVALIDITY_MARGINAL,
+ ALPM_SIGVALIDITY_NEVER,
+ ALPM_SIGVALIDITY_UNKNOWN
+} alpm_sigvalidity_t;
/*
- * Library
+ * Structures
*/
-int alpm_initialize(void);
-int alpm_release(void);
-const char *alpm_version(void);
+typedef struct __alpm_handle_t alpm_handle_t;
+typedef struct __alpm_db_t alpm_db_t;
+typedef struct __alpm_pkg_t alpm_pkg_t;
+typedef struct __alpm_trans_t alpm_trans_t;
+
+/** Dependency */
+typedef struct _alpm_depend_t {
+ char *name;
+ char *version;
+ unsigned long name_hash;
+ alpm_depmod_t mod;
+} alpm_depend_t;
+
+/** Missing dependency */
+typedef struct _alpm_depmissing_t {
+ char *target;
+ alpm_depend_t *depend;
+ /* this is used in case of remove dependency error only */
+ char *causingpkg;
+} alpm_depmissing_t;
+
+/** Conflict */
+typedef struct _alpm_conflict_t {
+ char *package1;
+ char *package2;
+ char *reason;
+} alpm_conflict_t;
+
+/** File conflict */
+typedef struct _alpm_fileconflict_t {
+ char *target;
+ alpm_fileconflicttype_t type;
+ char *file;
+ char *ctarget;
+} alpm_fileconflict_t;
+
+/** Package group */
+typedef struct _alpm_group_t {
+ /** group name */
+ char *name;
+ /** list of alpm_pkg_t packages */
+ alpm_list_t *packages;
+} alpm_group_t;
+
+/** Package upgrade delta */
+typedef struct _alpm_delta_t {
+ /** filename of the delta patch */
+ char *delta;
+ /** md5sum of the delta file */
+ char *delta_md5;
+ /** filename of the 'before' file */
+ char *from;
+ /** filename of the 'after' file */
+ char *to;
+ /** filesize of the delta file */
+ off_t delta_size;
+ /** download filesize of the delta file */
+ off_t download_size;
+} alpm_delta_t;
+
+/** File in a package */
+typedef struct _alpm_file_t {
+ char *name;
+ off_t size;
+ mode_t mode;
+} alpm_file_t;
+
+/** Package filelist container */
+typedef struct _alpm_filelist_t {
+ size_t count;
+ alpm_file_t *files;
+} alpm_filelist_t;
+
+/** Local package or package file backup entry */
+typedef struct _alpm_backup_t {
+ char *name;
+ char *hash;
+} alpm_backup_t;
+
+/** Signature result. Contains the number of signatures found and pointers to
+ * arrays containing key and status info. All contained arrays have size
+ * #count.*/
+typedef struct _alpm_sigresult_t {
+ int count;
+ alpm_sigstatus_t *status;
+ alpm_sigvalidity_t *validity;
+ char **uid;
+} alpm_sigresult_t;
/*
* Logging facilities
*/
-/* Levels */
-typedef enum _pmloglevel_t {
- PM_LOG_ERROR = 1,
- PM_LOG_WARNING = (1 << 1),
- PM_LOG_DEBUG = (1 << 2),
- PM_LOG_FUNCTION = (1 << 3)
-} pmloglevel_t;
+/**
+ * Logging Levels
+ */
+typedef enum _alpm_loglevel_t {
+ ALPM_LOG_ERROR = 1,
+ ALPM_LOG_WARNING = (1 << 1),
+ ALPM_LOG_DEBUG = (1 << 2),
+ ALPM_LOG_FUNCTION = (1 << 3)
+} alpm_loglevel_t;
-typedef void (*alpm_cb_log)(pmloglevel_t, const char *, va_list);
-int alpm_logaction(const char *fmt, ...);
+typedef void (*alpm_cb_log)(alpm_loglevel_t, const char *, va_list);
+int alpm_logaction(alpm_handle_t *handle, const char *fmt, ...);
/*
* Downloading
*/
+/** Type of download progress callbacks.
+ * @param filename the name of the file being downloaded
+ * @param xfered the number of transferred bytes
+ * @param total the total number of bytes to transfer
+ */
typedef void (*alpm_cb_download)(const char *filename,
off_t xfered, off_t total);
+
typedef void (*alpm_cb_totaldl)(off_t total);
+
/** A callback for downloading files
* @param url the URL of the file to be downloaded
* @param localpath the directory to which the file should be downloaded
@@ -99,111 +259,131 @@ typedef int (*alpm_cb_fetch)(const char *url, const char *localpath,
int force);
/** Fetch a remote pkg.
+ * @param handle the context handle
* @param url URL of the package to download
* @return the downloaded filepath on success, NULL on error
*/
-char *alpm_fetch_pkgurl(const char *url);
+char *alpm_fetch_pkgurl(alpm_handle_t *handle, const char *url);
/** @addtogroup alpm_api_options Options
* Libalpm option getters and setters
* @{
*/
-/** @name The logging callback. */
-/* @{ */
-alpm_cb_log alpm_option_get_logcb(void);
-void alpm_option_set_logcb(alpm_cb_log cb);
-/* @} */
+/** Returns the callback used for logging. */
+alpm_cb_log alpm_option_get_logcb(alpm_handle_t *handle);
+/** Sets the callback used for logging. */
+int alpm_option_set_logcb(alpm_handle_t *handle, alpm_cb_log cb);
-/** Get/set the download progress callback. */
-alpm_cb_download alpm_option_get_dlcb(void);
-void alpm_option_set_dlcb(alpm_cb_download cb);
+/** Returns the callback used to report download progress. */
+alpm_cb_download alpm_option_get_dlcb(alpm_handle_t *handle);
+/** Sets the callback used to report download progress. */
+int alpm_option_set_dlcb(alpm_handle_t *handle, alpm_cb_download cb);
-/** Get/set the downloader callback. */
-alpm_cb_fetch alpm_option_get_fetchcb(void);
-void alpm_option_set_fetchcb(alpm_cb_fetch cb);
+/** Returns the downloading callback. */
+alpm_cb_fetch alpm_option_get_fetchcb(alpm_handle_t *handle);
+/** Sets the downloading callback. */
+int alpm_option_set_fetchcb(alpm_handle_t *handle, alpm_cb_fetch cb);
-/** Get/set the callback used when download size is known. */
-alpm_cb_totaldl alpm_option_get_totaldlcb(void);
-void alpm_option_set_totaldlcb(alpm_cb_totaldl cb);
+/** Returns the callback used to report total download size. */
+alpm_cb_totaldl alpm_option_get_totaldlcb(alpm_handle_t *handle);
+/** Sets the callback used to report total download size. */
+int alpm_option_set_totaldlcb(alpm_handle_t *handle, alpm_cb_totaldl cb);
-/** Get/set the root of the destination filesystem. */
-const char *alpm_option_get_root(void);
-int alpm_option_set_root(const char *root);
+/** Returns the root of the destination filesystem. Read-only. */
+const char *alpm_option_get_root(alpm_handle_t *handle);
-/** Get/set the path to the database directory. */
-const char *alpm_option_get_dbpath(void);
-int alpm_option_set_dbpath(const char *dbpath);
+/** Returns the path to the database directory. Read-only. */
+const char *alpm_option_get_dbpath(alpm_handle_t *handle);
-/** Get/set the list of package cache directories. */
-alpm_list_t *alpm_option_get_cachedirs(void);
-void alpm_option_set_cachedirs(alpm_list_t *cachedirs);
+/** Get the name of the database lock file. Read-only. */
+const char *alpm_option_get_lockfile(alpm_handle_t *handle);
-/** Add a single directory to the package cache paths. */
-int alpm_option_add_cachedir(const char *cachedir);
+/** @name Accessors to the list of package cache directories.
+ * @{
+ */
+alpm_list_t *alpm_option_get_cachedirs(alpm_handle_t *handle);
+int alpm_option_set_cachedirs(alpm_handle_t *handle, alpm_list_t *cachedirs);
+int alpm_option_add_cachedir(alpm_handle_t *handle, const char *cachedir);
+int alpm_option_remove_cachedir(alpm_handle_t *handle, const char *cachedir);
+/** @} */
-/** Remove a single directory from the package cache paths. */
-int alpm_option_remove_cachedir(const char *cachedir);
+/** Returns the logfile name. */
+const char *alpm_option_get_logfile(alpm_handle_t *handle);
+/** Sets the logfile name. */
+int alpm_option_set_logfile(alpm_handle_t *handle, const char *logfile);
-/** Get/set the logfile name. */
-const char *alpm_option_get_logfile(void);
-int alpm_option_set_logfile(const char *logfile);
+/** Returns the path to libalpm's GnuPG home directory. */
+const char *alpm_option_get_gpgdir(alpm_handle_t *handle);
+/** Sets the path to libalpm's GnuPG home directory. */
+int alpm_option_set_gpgdir(alpm_handle_t *handle, const char *gpgdir);
-/** Get the name of the database lock file.
- *
- * This properly is read-only, and determined from
- * the database path.
- *
- * @sa alpm_option_set_dbpath(const char*)
- */
-const char *alpm_option_get_lockfile(void);
+/** Returns whether to use syslog (0 is FALSE, TRUE otherwise). */
+int alpm_option_get_usesyslog(alpm_handle_t *handle);
+/** Sets whether to use syslog (0 is FALSE, TRUE otherwise). */
+int alpm_option_set_usesyslog(alpm_handle_t *handle, int usesyslog);
-/** Get/set whether to use syslog (0 is FALSE, TRUE otherwise). */
-int alpm_option_get_usesyslog(void);
-void alpm_option_set_usesyslog(int usesyslog);
+/** @name Accessors to the list of no-upgrade files.
+ * These functions modify the list of files which should
+ * not be updated by package installation.
+ * @{
+ */
+alpm_list_t *alpm_option_get_noupgrades(alpm_handle_t *handle);
+int alpm_option_add_noupgrade(alpm_handle_t *handle, const char *pkg);
+int alpm_option_set_noupgrades(alpm_handle_t *handle, alpm_list_t *noupgrade);
+int alpm_option_remove_noupgrade(alpm_handle_t *handle, const char *pkg);
+/** @} */
-alpm_list_t *alpm_option_get_noupgrades(void);
-void alpm_option_add_noupgrade(const char *pkg);
-void alpm_option_set_noupgrades(alpm_list_t *noupgrade);
-int alpm_option_remove_noupgrade(const char *pkg);
+/** @name Accessors to the list of no-extract files.
+ * These functions modify the list of filenames which should
+ * be skipped packages which should
+ * not be upgraded by a sysupgrade operation.
+ * @{
+ */
+alpm_list_t *alpm_option_get_noextracts(alpm_handle_t *handle);
+int alpm_option_add_noextract(alpm_handle_t *handle, const char *pkg);
+int alpm_option_set_noextracts(alpm_handle_t *handle, alpm_list_t *noextract);
+int alpm_option_remove_noextract(alpm_handle_t *handle, const char *pkg);
+/** @} */
-alpm_list_t *alpm_option_get_noextracts(void);
-void alpm_option_add_noextract(const char *pkg);
-void alpm_option_set_noextracts(alpm_list_t *noextract);
-int alpm_option_remove_noextract(const char *pkg);
+/** @name Accessors to the list of ignored packages.
+ * These functions modify the list of packages that
+ * should be ignored by a sysupgrade.
+ * @{
+ */
+alpm_list_t *alpm_option_get_ignorepkgs(alpm_handle_t *handle);
+int alpm_option_add_ignorepkg(alpm_handle_t *handle, const char *pkg);
+int alpm_option_set_ignorepkgs(alpm_handle_t *handle, alpm_list_t *ignorepkgs);
+int alpm_option_remove_ignorepkg(alpm_handle_t *handle, const char *pkg);
+/** @} */
-alpm_list_t *alpm_option_get_ignorepkgs(void);
-void alpm_option_add_ignorepkg(const char *pkg);
-void alpm_option_set_ignorepkgs(alpm_list_t *ignorepkgs);
-int alpm_option_remove_ignorepkg(const char *pkg);
+/** @name Accessors to the list of ignored groups.
+ * These functions modify the list of groups whose packages
+ * should be ignored by a sysupgrade.
+ * @{
+ */
+alpm_list_t *alpm_option_get_ignoregroups(alpm_handle_t *handle);
+int alpm_option_add_ignoregroup(alpm_handle_t *handle, const char *grp);
+int alpm_option_set_ignoregroups(alpm_handle_t *handle, alpm_list_t *ignoregrps);
+int alpm_option_remove_ignoregroup(alpm_handle_t *handle, const char *grp);
+/** @} */
-alpm_list_t *alpm_option_get_ignoregrps(void);
-void alpm_option_add_ignoregrp(const char *grp);
-void alpm_option_set_ignoregrps(alpm_list_t *ignoregrps);
-int alpm_option_remove_ignoregrp(const char *grp);
+/** Returns the targeted architecture. */
+const char *alpm_option_get_arch(alpm_handle_t *handle);
+/** Sets the targeted architecture. */
+int alpm_option_set_arch(alpm_handle_t *handle, const char *arch);
-/** Get/set the targeted architecture. */
-const char *alpm_option_get_arch(void);
-void alpm_option_set_arch(const char *arch);
+int alpm_option_get_usedelta(alpm_handle_t *handle);
+int alpm_option_set_usedelta(alpm_handle_t *handle, int usedelta);
-int alpm_option_get_usedelta(void);
-void alpm_option_set_usedelta(int usedelta);
+int alpm_option_get_checkspace(alpm_handle_t *handle);
+int alpm_option_set_checkspace(alpm_handle_t *handle, int checkspace);
-int alpm_option_get_checkspace(void);
-void alpm_option_set_checkspace(int checkspace);
+alpm_siglevel_t alpm_option_get_default_siglevel(alpm_handle_t *handle);
+int alpm_option_set_default_siglevel(alpm_handle_t *handle, alpm_siglevel_t level);
/** @} */
-/** Install reasons
- * Why the package was installed.
- */
-typedef enum _pmpkgreason_t {
- /** Explicitly requested by the user. */
- PM_PKG_REASON_EXPLICIT = 0,
- /** Installed as a dependency for another package. */
- PM_PKG_REASON_DEPEND = 1
-} pmpkgreason_t;
-
/** @addtogroup alpm_api_databases Database Functions
* Functions to query and manipulate the database of libalpm.
* @{
@@ -215,93 +395,112 @@ typedef enum _pmpkgreason_t {
* libalpm functions.
* @return a reference to the local database
*/
-pmdb_t *alpm_option_get_localdb(void);
+alpm_db_t *alpm_option_get_localdb(alpm_handle_t *handle);
/** Get the list of sync databases.
- * Returns a list of pmdb_t structures, one for each registered
+ * Returns a list of alpm_db_t structures, one for each registered
* sync database.
- * @return a reference to an internal list of pmdb_t structures
+ * @param handle the context handle
+ * @return a reference to an internal list of alpm_db_t structures
*/
-alpm_list_t *alpm_option_get_syncdbs(void);
+alpm_list_t *alpm_option_get_syncdbs(alpm_handle_t *handle);
/** Register a sync database of packages.
+ * @param handle the context handle
* @param treename the name of the sync repository
- * @return a pmdb_t* on success (the value), NULL on error
+ * @param level what level of signature checking to perform on the
+ * database; note that this must be a '.sig' file type verification
+ * @return an alpm_db_t* on success (the value), NULL on error
*/
-pmdb_t *alpm_db_register_sync(const char *treename);
+alpm_db_t *alpm_db_register_sync(alpm_handle_t *handle, const char *treename,
+ alpm_siglevel_t level);
/** 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 alpm_db_unregister(pmdb_t *db);
+int alpm_db_unregister(alpm_db_t *db);
/** Unregister all package databases.
+ * @param handle the context handle
* @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
-int alpm_db_unregister_all(void);
+int alpm_db_unregister_all(alpm_handle_t *handle);
/** 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 *alpm_db_get_name(const pmdb_t *db);
+const char *alpm_db_get_name(const alpm_db_t *db);
-/** Get a download URL for the package database.
+/** Get the signature verification level for a database.
+ * Will return the default verification level if this database is set up
+ * with ALPM_SIG_USE_DEFAULT.
* @param db pointer to the package database
- * @return a fully-specified download URL, NULL on error
+ * @return the signature verification level
*/
-const char *alpm_db_get_url(const pmdb_t *db);
+alpm_siglevel_t alpm_db_get_siglevel(alpm_db_t *db);
-/** 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)
+/** Check the validity of a database.
+ * This is most useful for sync databases and verifying signature status.
+ * If invalid, the handle error code will be set accordingly.
+ * @param db pointer to the package database
+ * @return 0 if valid, -1 if invalid (pm_errno is set accordingly)
+ */
+int alpm_db_get_valid(alpm_db_t *db);
+
+/** @name Accessors to the list of servers for a database.
+ * @{
*/
-int alpm_db_setserver(pmdb_t *db, const char *url);
+alpm_list_t *alpm_db_get_servers(const alpm_db_t *db);
+int alpm_db_set_servers(alpm_db_t *db, alpm_list_t *servers);
+int alpm_db_add_server(alpm_db_t *db, const char *url);
+int alpm_db_remove_server(alpm_db_t *db, const char *url);
+/** @} */
-int alpm_db_update(int level, pmdb_t *db);
+int alpm_db_update(int level, alpm_db_t *db);
/** 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 *alpm_db_get_pkg(pmdb_t *db, const char *name);
+alpm_pkg_t *alpm_db_get_pkg(alpm_db_t *db, const char *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 *alpm_db_get_pkgcache(pmdb_t *db);
+alpm_list_t *alpm_db_get_pkgcache(alpm_db_t *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 *alpm_db_readgrp(pmdb_t *db, const char *name);
+alpm_group_t *alpm_db_readgroup(alpm_db_t *db, const char *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 *alpm_db_get_grpcache(pmdb_t *db);
+alpm_list_t *alpm_db_get_groupcache(alpm_db_t *db);
-/** Searches a database.
+/** Searches a database with regular expressions.
* @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
+ * @param needles a list of regular expressions to search for
+ * @return the list of packages matching all regular expressions on success, NULL on error
*/
-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);
/** Set install reason for a package in db.
- * @param db pointer to the package database
- * @param name the name of the package
+ * @param handle the context handle
+ * @param pkg the package to update
* @param reason the new install reason
* @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
-int alpm_db_set_pkgreason(pmdb_t *db, const char *name, pmpkgreason_t reason);
+int alpm_db_set_pkgreason(alpm_handle_t *handle, alpm_pkg_t *pkg,
+ alpm_pkgreason_t reason);
/** @} */
@@ -313,26 +512,31 @@ int alpm_db_set_pkgreason(pmdb_t *db, const char *name, pmpkgreason_t reason);
/** Create a package from a file.
* If full is false, the archive is read only until all necessary
* metadata is found. If it is true, the entire archive is read, which
- * serves as a verfication of integrity and the filelist can be created.
+ * serves as a verification of integrity and the filelist can be created.
+ * The allocated structure should be freed using alpm_pkg_free().
+ * @param handle the context handle
* @param filename location of the package tarball
* @param full whether to stop the load after metadata is read or continue
- * through the full archive
+ * through the full archive
+ * @param level what level of package signature checking to perform on the
+ * package; note that this must be a '.sig' file type verification
* @param pkg address of the package pointer
* @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
-int alpm_pkg_load(const char *filename, int full, pmpkg_t **pkg);
+int alpm_pkg_load(alpm_handle_t *handle, const char *filename, int full,
+ alpm_siglevel_t, alpm_pkg_t **pkg);
/** Free a package.
* @param pkg package pointer to free
* @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
-int alpm_pkg_free(pmpkg_t *pkg);
+int alpm_pkg_free(alpm_pkg_t *pkg);
/** Check the integrity (with md5) of a package from the sync cache.
* @param pkg package pointer
* @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
-int alpm_pkg_checkmd5sum(pmpkg_t *pkg);
+int alpm_pkg_checkmd5sum(alpm_pkg_t *pkg);
/** Compare two version strings and determine which one is 'newer'. */
int alpm_pkg_vercmp(const char *a, const char *b);
@@ -343,7 +547,7 @@ int alpm_pkg_vercmp(const char *a, const char *b);
* @param pkg a package
* @return the list of packages requiring pkg
*/
-alpm_list_t *alpm_pkg_compute_requiredby(pmpkg_t *pkg);
+alpm_list_t *alpm_pkg_compute_requiredby(alpm_pkg_t *pkg);
/** @name Package Property Accessors
* Any pointer returned by these functions points to internal structures
@@ -356,13 +560,13 @@ alpm_list_t *alpm_pkg_compute_requiredby(pmpkg_t *pkg);
* @param pkg a pointer to package
* @return a reference to an internal string
*/
-const char *alpm_pkg_get_filename(pmpkg_t *pkg);
+const char *alpm_pkg_get_filename(alpm_pkg_t *pkg);
/** Returns the package name.
* @param pkg a pointer to package
* @return a reference to an internal string
*/
-const char *alpm_pkg_get_name(pmpkg_t *pkg);
+const char *alpm_pkg_get_name(alpm_pkg_t *pkg);
/** Returns the package version as a string.
* This includes all available epoch, version, and pkgrel components. Use
@@ -370,124 +574,125 @@ const char *alpm_pkg_get_name(pmpkg_t *pkg);
* @param pkg a pointer to package
* @return a reference to an internal string
*/
-const char *alpm_pkg_get_version(pmpkg_t *pkg);
+const char *alpm_pkg_get_version(alpm_pkg_t *pkg);
/** Returns the package description.
* @param pkg a pointer to package
* @return a reference to an internal string
*/
-const char *alpm_pkg_get_desc(pmpkg_t *pkg);
+const char *alpm_pkg_get_desc(alpm_pkg_t *pkg);
/** Returns the package URL.
* @param pkg a pointer to package
* @return a reference to an internal string
*/
-const char *alpm_pkg_get_url(pmpkg_t *pkg);
+const char *alpm_pkg_get_url(alpm_pkg_t *pkg);
/** Returns the build timestamp of the package.
* @param pkg a pointer to package
* @return the timestamp of the build time
*/
-time_t alpm_pkg_get_builddate(pmpkg_t *pkg);
+time_t alpm_pkg_get_builddate(alpm_pkg_t *pkg);
/** Returns the install timestamp of the package.
* @param pkg a pointer to package
* @return the timestamp of the install time
*/
-time_t alpm_pkg_get_installdate(pmpkg_t *pkg);
+time_t alpm_pkg_get_installdate(alpm_pkg_t *pkg);
/** Returns the packager's name.
* @param pkg a pointer to package
* @return a reference to an internal string
*/
-const char *alpm_pkg_get_packager(pmpkg_t *pkg);
+const char *alpm_pkg_get_packager(alpm_pkg_t *pkg);
/** Returns the package's MD5 checksum as a string.
* The returned string is a sequence of lowercase hexadecimal digits.
* @param pkg a pointer to package
* @return a reference to an internal string
*/
-const char *alpm_pkg_get_md5sum(pmpkg_t *pkg);
+const char *alpm_pkg_get_md5sum(alpm_pkg_t *pkg);
/** Returns the architecture for which the package was built.
* @param pkg a pointer to package
* @return a reference to an internal string
*/
-const char *alpm_pkg_get_arch(pmpkg_t *pkg);
+const char *alpm_pkg_get_arch(alpm_pkg_t *pkg);
/** Returns the size of the package.
* @param pkg a pointer to package
* @return the size of the package in bytes.
*/
-off_t alpm_pkg_get_size(pmpkg_t *pkg);
+off_t alpm_pkg_get_size(alpm_pkg_t *pkg);
/** Returns the installed size of the package.
* @param pkg a pointer to package
* @return the total size of files installed by the package.
*/
-off_t alpm_pkg_get_isize(pmpkg_t *pkg);
+off_t alpm_pkg_get_isize(alpm_pkg_t *pkg);
/** Returns the package installation reason.
* @param pkg a pointer to package
* @return an enum member giving the install reason.
*/
-pmpkgreason_t alpm_pkg_get_reason(pmpkg_t *pkg);
+alpm_pkgreason_t alpm_pkg_get_reason(alpm_pkg_t *pkg);
/** Returns the list of package licenses.
* @param pkg a pointer to package
* @return a pointer to an internal list of strings.
*/
-alpm_list_t *alpm_pkg_get_licenses(pmpkg_t *pkg);
+alpm_list_t *alpm_pkg_get_licenses(alpm_pkg_t *pkg);
/** Returns the list of package groups.
* @param pkg a pointer to package
* @return a pointer to an internal list of strings.
*/
-alpm_list_t *alpm_pkg_get_groups(pmpkg_t *pkg);
+alpm_list_t *alpm_pkg_get_groups(alpm_pkg_t *pkg);
-/** Returns the list of package dependencies as pmdepend_t.
+/** Returns the list of package dependencies as alpm_depend_t.
* @param pkg a pointer to package
- * @return a reference to an internal list of pmdepend_t structures.
+ * @return a reference to an internal list of alpm_depend_t structures.
*/
-alpm_list_t *alpm_pkg_get_depends(pmpkg_t *pkg);
+alpm_list_t *alpm_pkg_get_depends(alpm_pkg_t *pkg);
/** Returns the list of package optional dependencies.
* @param pkg a pointer to package
* @return a reference to an internal list of strings.
*/
-alpm_list_t *alpm_pkg_get_optdepends(pmpkg_t *pkg);
+alpm_list_t *alpm_pkg_get_optdepends(alpm_pkg_t *pkg);
/** Returns the list of package names conflicting with pkg.
* @param pkg a pointer to package
* @return a reference to an internal list of strings.
*/
-alpm_list_t *alpm_pkg_get_conflicts(pmpkg_t *pkg);
+alpm_list_t *alpm_pkg_get_conflicts(alpm_pkg_t *pkg);
/** Returns the list of package names provided by pkg.
* @param pkg a pointer to package
* @return a reference to an internal list of strings.
*/
-alpm_list_t *alpm_pkg_get_provides(pmpkg_t *pkg);
+alpm_list_t *alpm_pkg_get_provides(alpm_pkg_t *pkg);
/** Returns the list of available deltas for pkg.
* @param pkg a pointer to package
* @return a reference to an internal list of strings.
*/
-alpm_list_t *alpm_pkg_get_deltas(pmpkg_t *pkg);
+alpm_list_t *alpm_pkg_get_deltas(alpm_pkg_t *pkg);
/** Returns the list of packages to be replaced by pkg.
* @param pkg a pointer to package
* @return a reference to an internal list of strings.
*/
-alpm_list_t *alpm_pkg_get_replaces(pmpkg_t *pkg);
+alpm_list_t *alpm_pkg_get_replaces(alpm_pkg_t *pkg);
/** Returns the list of files installed by pkg.
* The filenames are relative to the install root,
* and do not include leading slashes.
* @param pkg a pointer to package
- * @return a reference to an internal list of strings.
+ * @return a pointer to a filelist object containing a count and an array of
+ * package file objects
*/
-alpm_list_t *alpm_pkg_get_files(pmpkg_t *pkg);
+alpm_filelist_t *alpm_pkg_get_files(alpm_pkg_t *pkg);
/** Returns the list of files backed up when installing pkg.
* The elements of the returned list have the form
@@ -496,17 +701,17 @@ alpm_list_t *alpm_pkg_get_files(pmpkg_t *pkg);
* @param pkg a pointer to package
* @return a reference to an internal list of strings.
*/
-alpm_list_t *alpm_pkg_get_backup(pmpkg_t *pkg);
+alpm_list_t *alpm_pkg_get_backup(alpm_pkg_t *pkg);
-/** Returns the database containing pkg
- * Returns a pointer to the pmdb_t structure the package is
- * originating from, or NULL is the package was loaded from a file.
+/** Returns the database containing pkg.
+ * Returns a pointer to the alpm_db_t structure the package is
+ * originating from, or NULL if the package was loaded from a file.
* @param pkg a pointer to package
* @return a pointer to the DB containing pkg, or NULL.
*/
-pmdb_t *alpm_pkg_get_db(pmpkg_t *pkg);
+alpm_db_t *alpm_pkg_get_db(alpm_pkg_t *pkg);
-/* End of pmpkg_t accessors */
+/* End of alpm_pkg_t accessors */
/* @} */
/** Open a package changelog for reading.
@@ -515,7 +720,7 @@ pmdb_t *alpm_pkg_get_db(pmpkg_t *pkg);
* @param pkg the package to read the changelog of (either file or db)
* @return a 'file stream' to the package changelog
*/
-void *alpm_pkg_changelog_open(pmpkg_t *pkg);
+void *alpm_pkg_changelog_open(alpm_pkg_t *pkg);
/** Read data from an open changelog 'file stream'.
* Similar to fread in functionality, this function takes a buffer and
@@ -528,13 +733,16 @@ void *alpm_pkg_changelog_open(pmpkg_t *pkg);
* error occurred.
*/
size_t alpm_pkg_changelog_read(void *ptr, size_t size,
- const pmpkg_t *pkg, const void *fp);
+ const alpm_pkg_t *pkg, const void *fp);
-/*int alpm_pkg_changelog_feof(const pmpkg_t *pkg, void *fp);*/
+/*int alpm_pkg_changelog_feof(const alpm_pkg_t *pkg, void *fp);*/
-int alpm_pkg_changelog_close(const pmpkg_t *pkg, void *fp);
+int alpm_pkg_changelog_close(const alpm_pkg_t *pkg, void *fp);
-int alpm_pkg_has_scriptlet(pmpkg_t *pkg);
+/** Returns whether the package has an install scriptlet.
+ * @return 0 if FALSE, TRUE otherwise
+ */
+int alpm_pkg_has_scriptlet(alpm_pkg_t *pkg);
/** Returns the size of download.
* Returns the size of the files that will be downloaded to install a
@@ -542,35 +750,34 @@ int alpm_pkg_has_scriptlet(pmpkg_t *pkg);
* @param newpkg the new package to upgrade to
* @return the size of the download
*/
-off_t alpm_pkg_download_size(pmpkg_t *newpkg);
+off_t alpm_pkg_download_size(alpm_pkg_t *newpkg);
-alpm_list_t *alpm_pkg_unused_deltas(pmpkg_t *pkg);
+alpm_list_t *alpm_pkg_unused_deltas(alpm_pkg_t *pkg);
/* End of alpm_pkg */
/** @} */
/*
- * Deltas
+ * Signatures
*/
-const char *alpm_delta_get_from(pmdelta_t *delta);
-const char *alpm_delta_get_to(pmdelta_t *delta);
-const char *alpm_delta_get_filename(pmdelta_t *delta);
-const char *alpm_delta_get_md5sum(pmdelta_t *delta);
-off_t alpm_delta_get_size(pmdelta_t *delta);
+int alpm_pkg_check_pgp_signature(alpm_pkg_t *pkg, alpm_sigresult_t *result);
+
+int alpm_db_check_pgp_signature(alpm_db_t *db, alpm_sigresult_t *result);
+
+int alpm_sigresult_cleanup(alpm_sigresult_t *result);
/*
* Groups
*/
-const char *alpm_grp_get_name(const pmgrp_t *grp);
-alpm_list_t *alpm_grp_get_pkgs(const pmgrp_t *grp);
-alpm_list_t *alpm_find_grp_pkgs(alpm_list_t *dbs, const char *name);
+
+alpm_list_t *alpm_find_group_pkgs(alpm_list_t *dbs, const char *name);
/*
* Sync
*/
-pmpkg_t *alpm_sync_newversion(pmpkg_t *pkg, alpm_list_t *dbs_sync);
+alpm_pkg_t *alpm_sync_newversion(alpm_pkg_t *pkg, alpm_list_t *dbs_sync);
/** @addtogroup alpm_api_trans Transaction Functions
* Functions to manipulate libalpm transactions
@@ -578,290 +785,263 @@ pmpkg_t *alpm_sync_newversion(pmpkg_t *pkg, alpm_list_t *dbs_sync);
*/
/** Transaction flags */
-typedef enum _pmtransflag_t {
+typedef enum _alpm_transflag_t {
/** Ignore dependency checks. */
- PM_TRANS_FLAG_NODEPS = 1,
+ ALPM_TRANS_FLAG_NODEPS = 1,
/** Ignore file conflicts and overwrite files. */
- PM_TRANS_FLAG_FORCE = (1 << 1),
+ ALPM_TRANS_FLAG_FORCE = (1 << 1),
/** Delete files even if they are tagged as backup. */
- PM_TRANS_FLAG_NOSAVE = (1 << 2),
+ ALPM_TRANS_FLAG_NOSAVE = (1 << 2),
/** Ignore version numbers when checking dependencies. */
- PM_TRANS_FLAG_NODEPVERSION = (1 << 3),
+ ALPM_TRANS_FLAG_NODEPVERSION = (1 << 3),
/** Remove also any packages depending on a package being removed. */
- PM_TRANS_FLAG_CASCADE = (1 << 4),
+ ALPM_TRANS_FLAG_CASCADE = (1 << 4),
/** Remove packages and their unneeded deps (not explicitly installed). */
- PM_TRANS_FLAG_RECURSE = (1 << 5),
+ ALPM_TRANS_FLAG_RECURSE = (1 << 5),
/** Modify database but do not commit changes to the filesystem. */
- PM_TRANS_FLAG_DBONLY = (1 << 6),
+ ALPM_TRANS_FLAG_DBONLY = (1 << 6),
/* (1 << 7) flag can go here */
- /** Use PM_PKG_REASON_DEPEND when installing packages. */
- PM_TRANS_FLAG_ALLDEPS = (1 << 8),
+ /** Use ALPM_PKG_REASON_DEPEND when installing packages. */
+ ALPM_TRANS_FLAG_ALLDEPS = (1 << 8),
/** Only download packages and do not actually install. */
- PM_TRANS_FLAG_DOWNLOADONLY = (1 << 9),
+ ALPM_TRANS_FLAG_DOWNLOADONLY = (1 << 9),
/** Do not execute install scriptlets after installing. */
- PM_TRANS_FLAG_NOSCRIPTLET = (1 << 10),
+ ALPM_TRANS_FLAG_NOSCRIPTLET = (1 << 10),
/** Ignore dependency conflicts. */
- PM_TRANS_FLAG_NOCONFLICTS = (1 << 11),
+ ALPM_TRANS_FLAG_NOCONFLICTS = (1 << 11),
/* (1 << 12) flag can go here */
/** Do not install a package if it is already installed and up to date. */
- PM_TRANS_FLAG_NEEDED = (1 << 13),
- /** Use PM_PKG_REASON_EXPLICIT when installing packages. */
- PM_TRANS_FLAG_ALLEXPLICIT = (1 << 14),
+ ALPM_TRANS_FLAG_NEEDED = (1 << 13),
+ /** Use ALPM_PKG_REASON_EXPLICIT when installing packages. */
+ ALPM_TRANS_FLAG_ALLEXPLICIT = (1 << 14),
/** Do not remove a package if it is needed by another one. */
- PM_TRANS_FLAG_UNNEEDED = (1 << 15),
- /** Remove also explicitly installed unneeded deps (use with PM_TRANS_FLAG_RECURSE). */
- PM_TRANS_FLAG_RECURSEALL = (1 << 16),
+ ALPM_TRANS_FLAG_UNNEEDED = (1 << 15),
+ /** Remove also explicitly installed unneeded deps (use with ALPM_TRANS_FLAG_RECURSE). */
+ ALPM_TRANS_FLAG_RECURSEALL = (1 << 16),
/** Do not lock the database during the operation. */
- PM_TRANS_FLAG_NOLOCK = (1 << 17)
-} pmtransflag_t;
+ ALPM_TRANS_FLAG_NOLOCK = (1 << 17)
+} alpm_transflag_t;
/** Transaction events.
* NULL parameters are passed to in all events unless specified otherwise.
*/
-typedef enum _pmtransevt_t {
+typedef enum _alpm_transevt_t {
/** Dependencies will be computed for a package. */
- PM_TRANS_EVT_CHECKDEPS_START = 1,
+ ALPM_TRANS_EVT_CHECKDEPS_START = 1,
/** Dependencies were computed for a package. */
- PM_TRANS_EVT_CHECKDEPS_DONE,
+ ALPM_TRANS_EVT_CHECKDEPS_DONE,
/** File conflicts will be computed for a package. */
- PM_TRANS_EVT_FILECONFLICTS_START,
+ ALPM_TRANS_EVT_FILECONFLICTS_START,
/** File conflicts were computed for a package. */
- PM_TRANS_EVT_FILECONFLICTS_DONE,
+ ALPM_TRANS_EVT_FILECONFLICTS_DONE,
/** Dependencies will be resolved for target package. */
- PM_TRANS_EVT_RESOLVEDEPS_START,
+ ALPM_TRANS_EVT_RESOLVEDEPS_START,
/** Dependencies were resolved for target package. */
- PM_TRANS_EVT_RESOLVEDEPS_DONE,
+ ALPM_TRANS_EVT_RESOLVEDEPS_DONE,
/** Inter-conflicts will be checked for target package. */
- PM_TRANS_EVT_INTERCONFLICTS_START,
+ ALPM_TRANS_EVT_INTERCONFLICTS_START,
/** Inter-conflicts were checked for target package. */
- PM_TRANS_EVT_INTERCONFLICTS_DONE,
+ ALPM_TRANS_EVT_INTERCONFLICTS_DONE,
/** Package will be installed.
* A pointer to the target package is passed to the callback.
*/
- PM_TRANS_EVT_ADD_START,
+ ALPM_TRANS_EVT_ADD_START,
/** Package was installed.
* A pointer to the new package is passed to the callback.
*/
- PM_TRANS_EVT_ADD_DONE,
+ ALPM_TRANS_EVT_ADD_DONE,
/** Package will be removed.
* A pointer to the target package is passed to the callback.
*/
- PM_TRANS_EVT_REMOVE_START,
+ ALPM_TRANS_EVT_REMOVE_START,
/** Package was removed.
* A pointer to the removed package is passed to the callback.
*/
- PM_TRANS_EVT_REMOVE_DONE,
+ ALPM_TRANS_EVT_REMOVE_DONE,
/** Package will be upgraded.
* A pointer to the upgraded package is passed to the callback.
*/
- PM_TRANS_EVT_UPGRADE_START,
+ ALPM_TRANS_EVT_UPGRADE_START,
/** Package was upgraded.
* A pointer to the new package, and a pointer to the old package is passed
* to the callback, respectively.
*/
- PM_TRANS_EVT_UPGRADE_DONE,
+ ALPM_TRANS_EVT_UPGRADE_DONE,
/** Target package's integrity will be checked. */
- PM_TRANS_EVT_INTEGRITY_START,
+ ALPM_TRANS_EVT_INTEGRITY_START,
/** Target package's integrity was checked. */
- PM_TRANS_EVT_INTEGRITY_DONE,
+ ALPM_TRANS_EVT_INTEGRITY_DONE,
/** Target deltas's integrity will be checked. */
- PM_TRANS_EVT_DELTA_INTEGRITY_START,
+ ALPM_TRANS_EVT_DELTA_INTEGRITY_START,
/** Target delta's integrity was checked. */
- PM_TRANS_EVT_DELTA_INTEGRITY_DONE,
+ ALPM_TRANS_EVT_DELTA_INTEGRITY_DONE,
/** Deltas will be applied to packages. */
- PM_TRANS_EVT_DELTA_PATCHES_START,
+ ALPM_TRANS_EVT_DELTA_PATCHES_START,
/** Deltas were applied to packages. */
- PM_TRANS_EVT_DELTA_PATCHES_DONE,
+ ALPM_TRANS_EVT_DELTA_PATCHES_DONE,
/** Delta patch will be applied to target package.
* The filename of the package and the filename of the patch is passed to the
* callback.
*/
- PM_TRANS_EVT_DELTA_PATCH_START,
+ ALPM_TRANS_EVT_DELTA_PATCH_START,
/** Delta patch was applied to target package. */
- PM_TRANS_EVT_DELTA_PATCH_DONE,
+ ALPM_TRANS_EVT_DELTA_PATCH_DONE,
/** Delta patch failed to apply to target package. */
- PM_TRANS_EVT_DELTA_PATCH_FAILED,
+ ALPM_TRANS_EVT_DELTA_PATCH_FAILED,
/** Scriptlet has printed information.
* A line of text is passed to the callback.
*/
- PM_TRANS_EVT_SCRIPTLET_INFO,
+ ALPM_TRANS_EVT_SCRIPTLET_INFO,
/** Files will be downloaded from a repository.
* The repository's tree name is passed to the callback.
*/
- PM_TRANS_EVT_RETRIEVE_START,
+ ALPM_TRANS_EVT_RETRIEVE_START,
/** Disk space usage will be computed for a package */
- PM_TRANS_EVT_DISKSPACE_START,
+ ALPM_TRANS_EVT_DISKSPACE_START,
/** Disk space usage was computed for a package */
- PM_TRANS_EVT_DISKSPACE_DONE,
-} pmtransevt_t;
+ ALPM_TRANS_EVT_DISKSPACE_DONE,
+} alpm_transevt_t;
/** Transaction Conversations (ie, questions) */
-typedef enum _pmtransconv_t {
- PM_TRANS_CONV_INSTALL_IGNOREPKG = 1,
- PM_TRANS_CONV_REPLACE_PKG = (1 << 1),
- PM_TRANS_CONV_CONFLICT_PKG = (1 << 2),
- PM_TRANS_CONV_CORRUPTED_PKG = (1 << 3),
- PM_TRANS_CONV_LOCAL_NEWER = (1 << 4),
- PM_TRANS_CONV_REMOVE_PKGS = (1 << 5),
- PM_TRANS_CONV_SELECT_PROVIDER = (1 << 6),
-} pmtransconv_t;
+typedef enum _alpm_transconv_t {
+ ALPM_TRANS_CONV_INSTALL_IGNOREPKG = 1,
+ ALPM_TRANS_CONV_REPLACE_PKG = (1 << 1),
+ ALPM_TRANS_CONV_CONFLICT_PKG = (1 << 2),
+ ALPM_TRANS_CONV_CORRUPTED_PKG = (1 << 3),
+ ALPM_TRANS_CONV_LOCAL_NEWER = (1 << 4),
+ ALPM_TRANS_CONV_REMOVE_PKGS = (1 << 5),
+ ALPM_TRANS_CONV_SELECT_PROVIDER = (1 << 6),
+} alpm_transconv_t;
/** Transaction Progress */
-typedef enum _pmtransprog_t {
- PM_TRANS_PROGRESS_ADD_START,
- PM_TRANS_PROGRESS_UPGRADE_START,
- PM_TRANS_PROGRESS_REMOVE_START,
- PM_TRANS_PROGRESS_CONFLICTS_START,
- PM_TRANS_PROGRESS_DISKSPACE_START,
- PM_TRANS_PROGRESS_INTEGRITY_START,
-} pmtransprog_t;
+typedef enum _alpm_transprog_t {
+ ALPM_TRANS_PROGRESS_ADD_START,
+ ALPM_TRANS_PROGRESS_UPGRADE_START,
+ ALPM_TRANS_PROGRESS_REMOVE_START,
+ ALPM_TRANS_PROGRESS_CONFLICTS_START,
+ ALPM_TRANS_PROGRESS_DISKSPACE_START,
+ ALPM_TRANS_PROGRESS_INTEGRITY_START,
+} alpm_transprog_t;
/** Transaction Event callback */
-typedef void (*alpm_trans_cb_event)(pmtransevt_t, void *, void *);
+typedef void (*alpm_trans_cb_event)(alpm_transevt_t, void *, void *);
/** Transaction Conversation callback */
-typedef void (*alpm_trans_cb_conv)(pmtransconv_t, void *, void *,
+typedef void (*alpm_trans_cb_conv)(alpm_transconv_t, void *, void *,
void *, int *);
/** Transaction Progress callback */
-typedef void (*alpm_trans_cb_progress)(pmtransprog_t, const char *, int, size_t, size_t);
+typedef void (*alpm_trans_cb_progress)(alpm_transprog_t, const char *, int, size_t, size_t);
-int alpm_trans_get_flags(void);
+/** Returns the bitfield of flags for the current transaction.
+ * @param handle the context handle
+ * @return the bitfield of transaction flags
+ */
+alpm_transflag_t alpm_trans_get_flags(alpm_handle_t *handle);
/** Returns a list of packages added by the transaction.
- * @return a list of pmpkg_t structures
+ * @param handle the context handle
+ * @return a list of alpm_pkg_t structures
*/
-alpm_list_t * alpm_trans_get_add(void);
+alpm_list_t * alpm_trans_get_add(alpm_handle_t *handle);
/** Returns the list of packages removed by the transaction.
- * @return a list of pmpkg_t structures
+ * @param handle the context handle
+ * @return a list of alpm_pkg_t structures
*/
-alpm_list_t * alpm_trans_get_remove(void);
+alpm_list_t * alpm_trans_get_remove(alpm_handle_t *handle);
/** Initialize the transaction.
+ * @param handle the context handle
* @param flags flags of the transaction (like nodeps, etc)
* @param event event callback function pointer
* @param conv question callback function pointer
* @param progress progress callback function pointer
* @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
-int alpm_trans_init(pmtransflag_t flags,
+int alpm_trans_init(alpm_handle_t *handle, alpm_transflag_t flags,
alpm_trans_cb_event cb_event, alpm_trans_cb_conv conv,
alpm_trans_cb_progress cb_progress);
/** Prepare a transaction.
+ * @param handle the context handle
* @param data the address of an alpm_list where a list
- * of pmdepmissing_t objects is dumped (conflicting packages)
+ * of alpm_depmissing_t objects is dumped (conflicting packages)
* @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
-int alpm_trans_prepare(alpm_list_t **data);
+int alpm_trans_prepare(alpm_handle_t *handle, alpm_list_t **data);
/** Commit a transaction.
+ * @param handle the context handle
* @param data the address of an alpm_list where detailed description
* of an error can be dumped (ie. list of conflicting files)
* @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
-int alpm_trans_commit(alpm_list_t **data);
+int alpm_trans_commit(alpm_handle_t *handle, alpm_list_t **data);
/** Interrupt a transaction.
+ * @param handle the context handle
* @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
-int alpm_trans_interrupt(void);
+int alpm_trans_interrupt(alpm_handle_t *handle);
/** Release a transaction.
+ * @param handle the context handle
* @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
-int alpm_trans_release(void);
+int alpm_trans_release(alpm_handle_t *handle);
/** @} */
/** @name Common Transactions */
/** @{ */
-int alpm_sync_sysupgrade(int enable_downgrade);
-int alpm_add_pkg(pmpkg_t *pkg);
-int alpm_remove_pkg(pmpkg_t *pkg);
-/** @} */
-/** @addtogroup alpm_api_depends Dependency Functions
- * Functions dealing with libalpm representation of dependency
- * information.
- * @{
+/** Search for packages to upgrade and add them to the transaction.
+ * @param handle the context handle
+ * @param enable_downgrade allow downgrading of packages if the remote version is lower
+ * @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
+int alpm_sync_sysupgrade(alpm_handle_t *handle, int enable_downgrade);
-/** Types of version constraints in dependency specs. */
-typedef enum _pmdepmod_t {
- /** No version constraint */
- PM_DEP_MOD_ANY = 1,
- /** Test version equality (package=x.y.z) */
- PM_DEP_MOD_EQ,
- /** Test for at least a version (package>=x.y.z) */
- PM_DEP_MOD_GE,
- /** Test for at most a version (package<=x.y.z) */
- PM_DEP_MOD_LE,
- /** Test for greater than some version (package>x.y.z) */
- PM_DEP_MOD_GT,
- /** Test for less than some version (package<x.y.z) */
- PM_DEP_MOD_LT
-} pmdepmod_t;
-
-alpm_list_t *alpm_checkdeps(alpm_list_t *pkglist, int reversedeps,
- alpm_list_t *remove, alpm_list_t *upgrade);
-pmpkg_t *alpm_find_satisfier(alpm_list_t *pkgs, const char *depstring);
-pmpkg_t *alpm_find_dbs_satisfier(alpm_list_t *dbs, const char *depstring);
-
-const char *alpm_miss_get_target(const pmdepmissing_t *miss);
-pmdepend_t *alpm_miss_get_dep(pmdepmissing_t *miss);
-const char *alpm_miss_get_causingpkg(const pmdepmissing_t *miss);
+/** Add a package to the transaction.
+ * If the package was loaded by alpm_pkg_load(), it will be freed upon
+ * alpm_trans_release() invocation.
+ * @param handle the context handle
+ * @param pkg the package to add
+ * @return 0 on success, -1 on error (pm_errno is set accordingly)
+ */
+int alpm_add_pkg(alpm_handle_t *handle, alpm_pkg_t *pkg);
-alpm_list_t *alpm_checkconflicts(alpm_list_t *pkglist);
+/** Add a package removal action to the transaction.
+ * @param handle the context handle
+ * @param pkg the package to uninstall
+ * @return 0 on success, -1 on error (pm_errno is set accordingly)
+ */
+int alpm_remove_pkg(alpm_handle_t *handle, alpm_pkg_t *pkg);
-const char *alpm_conflict_get_package1(pmconflict_t *conflict);
-const char *alpm_conflict_get_package2(pmconflict_t *conflict);
-const char *alpm_conflict_get_reason(pmconflict_t *conflict);
+/** @} */
-/** Returns the type of version constraint.
- * @param dep a dependency info structure
- * @return the type of version constraint (PM_DEP_MOD_ANY if no version
- * is specified).
+/** @addtogroup alpm_api_depends Dependency Functions
+ * Functions dealing with libalpm representation of dependency
+ * information.
+ * @{
*/
-pmdepmod_t alpm_dep_get_mod(const pmdepend_t *dep);
-/** Returns the package name of a dependency constraint.
- * @param dep a dependency info structure
- * @return a pointer to an internal string.
- */
-const char *alpm_dep_get_name(const pmdepend_t *dep);
+alpm_list_t *alpm_checkdeps(alpm_handle_t *handle, alpm_list_t *pkglist,
+ alpm_list_t *remove, alpm_list_t *upgrade, int reversedeps);
+alpm_pkg_t *alpm_find_satisfier(alpm_list_t *pkgs, const char *depstring);
+alpm_pkg_t *alpm_find_dbs_satisfier(alpm_handle_t *handle,
+ alpm_list_t *dbs, const char *depstring);
-/** Returns the version specified by a dependency constraint.
- * The version information is returned as a string in the same format
- * as given by alpm_pkg_get_version().
- * @param dep a dependency info structure
- * @return a pointer to an internal string.
- */
-const char *alpm_dep_get_version(const pmdepend_t *dep);
+alpm_list_t *alpm_checkconflicts(alpm_handle_t *handle, alpm_list_t *pkglist);
/** Returns a newly allocated string representing the dependency information.
* @param dep a dependency info structure
* @return a formatted string, e.g. "glibc>=2.12"
*/
-char *alpm_dep_compute_string(const pmdepend_t *dep);
+char *alpm_dep_compute_string(const alpm_depend_t *dep);
/** @} */
-/** @addtogroup alpm_api_fileconflicts File Conflicts Functions
- * Functions to manipulate file conflict information.
- * @{
- */
-
-typedef enum _pmfileconflicttype_t {
- PM_FILECONFLICT_TARGET = 1,
- PM_FILECONFLICT_FILESYSTEM
-} pmfileconflicttype_t;
-
-const char *alpm_fileconflict_get_target(pmfileconflict_t *conflict);
-pmfileconflicttype_t alpm_fileconflict_get_type(pmfileconflict_t *conflict);
-const char *alpm_fileconflict_get_file(pmfileconflict_t *conflict);
-const char *alpm_fileconflict_get_ctarget(pmfileconflict_t *conflict);
-
/** @} */
/*
@@ -874,77 +1054,85 @@ char *alpm_compute_md5sum(const char *name);
/** @addtogroup alpm_api_errors Error Codes
* @{
*/
-enum _pmerrno_t {
- PM_ERR_MEMORY = 1,
- PM_ERR_SYSTEM,
- PM_ERR_BADPERMS,
- PM_ERR_NOT_A_FILE,
- PM_ERR_NOT_A_DIR,
- PM_ERR_WRONG_ARGS,
- PM_ERR_DISK_SPACE,
+enum _alpm_errno_t {
+ ALPM_ERR_MEMORY = 1,
+ ALPM_ERR_SYSTEM,
+ ALPM_ERR_BADPERMS,
+ ALPM_ERR_NOT_A_FILE,
+ ALPM_ERR_NOT_A_DIR,
+ ALPM_ERR_WRONG_ARGS,
+ ALPM_ERR_DISK_SPACE,
/* Interface */
- PM_ERR_HANDLE_NULL,
- PM_ERR_HANDLE_NOT_NULL,
- PM_ERR_HANDLE_LOCK,
+ ALPM_ERR_HANDLE_NULL,
+ ALPM_ERR_HANDLE_NOT_NULL,
+ ALPM_ERR_HANDLE_LOCK,
/* Databases */
- PM_ERR_DB_OPEN,
- PM_ERR_DB_CREATE,
- PM_ERR_DB_NULL,
- PM_ERR_DB_NOT_NULL,
- PM_ERR_DB_NOT_FOUND,
- PM_ERR_DB_VERSION,
- PM_ERR_DB_WRITE,
- PM_ERR_DB_REMOVE,
+ ALPM_ERR_DB_OPEN,
+ ALPM_ERR_DB_CREATE,
+ ALPM_ERR_DB_NULL,
+ ALPM_ERR_DB_NOT_NULL,
+ ALPM_ERR_DB_NOT_FOUND,
+ ALPM_ERR_DB_INVALID,
+ ALPM_ERR_DB_INVALID_SIG,
+ ALPM_ERR_DB_VERSION,
+ ALPM_ERR_DB_WRITE,
+ ALPM_ERR_DB_REMOVE,
/* Servers */
- PM_ERR_SERVER_BAD_URL,
- PM_ERR_SERVER_NONE,
+ ALPM_ERR_SERVER_BAD_URL,
+ ALPM_ERR_SERVER_NONE,
/* Transactions */
- PM_ERR_TRANS_NOT_NULL,
- PM_ERR_TRANS_NULL,
- PM_ERR_TRANS_DUP_TARGET,
- PM_ERR_TRANS_NOT_INITIALIZED,
- PM_ERR_TRANS_NOT_PREPARED,
- PM_ERR_TRANS_ABORT,
- PM_ERR_TRANS_TYPE,
- PM_ERR_TRANS_NOT_LOCKED,
+ ALPM_ERR_TRANS_NOT_NULL,
+ ALPM_ERR_TRANS_NULL,
+ ALPM_ERR_TRANS_DUP_TARGET,
+ ALPM_ERR_TRANS_NOT_INITIALIZED,
+ ALPM_ERR_TRANS_NOT_PREPARED,
+ ALPM_ERR_TRANS_ABORT,
+ ALPM_ERR_TRANS_TYPE,
+ ALPM_ERR_TRANS_NOT_LOCKED,
/* Packages */
- PM_ERR_PKG_NOT_FOUND,
- PM_ERR_PKG_IGNORED,
- PM_ERR_PKG_INVALID,
- PM_ERR_PKG_OPEN,
- PM_ERR_PKG_CANT_REMOVE,
- PM_ERR_PKG_INVALID_NAME,
- PM_ERR_PKG_INVALID_ARCH,
- PM_ERR_PKG_REPO_NOT_FOUND,
+ ALPM_ERR_PKG_NOT_FOUND,
+ ALPM_ERR_PKG_IGNORED,
+ ALPM_ERR_PKG_INVALID,
+ ALPM_ERR_PKG_INVALID_SIG,
+ ALPM_ERR_PKG_OPEN,
+ ALPM_ERR_PKG_CANT_REMOVE,
+ ALPM_ERR_PKG_INVALID_NAME,
+ ALPM_ERR_PKG_INVALID_ARCH,
+ ALPM_ERR_PKG_REPO_NOT_FOUND,
+ /* Signatures */
+ ALPM_ERR_SIG_MISSING,
+ ALPM_ERR_SIG_INVALID,
/* Deltas */
- PM_ERR_DLT_INVALID,
- PM_ERR_DLT_PATCHFAILED,
+ ALPM_ERR_DLT_INVALID,
+ ALPM_ERR_DLT_PATCHFAILED,
/* Dependencies */
- PM_ERR_UNSATISFIED_DEPS,
- PM_ERR_CONFLICTING_DEPS,
- PM_ERR_FILE_CONFLICTS,
+ ALPM_ERR_UNSATISFIED_DEPS,
+ ALPM_ERR_CONFLICTING_DEPS,
+ ALPM_ERR_FILE_CONFLICTS,
/* Misc */
- PM_ERR_RETRIEVE,
- PM_ERR_WRITE,
- PM_ERR_INVALID_REGEX,
+ ALPM_ERR_RETRIEVE,
+ ALPM_ERR_INVALID_REGEX,
/* External library errors */
- PM_ERR_LIBARCHIVE,
- PM_ERR_LIBFETCH,
- PM_ERR_EXTERNAL_DOWNLOAD
+ ALPM_ERR_LIBARCHIVE,
+ ALPM_ERR_LIBCURL,
+ ALPM_ERR_EXTERNAL_DOWNLOAD,
+ ALPM_ERR_GPGME
};
-/** The number of the last error that occurred. */
-extern enum _pmerrno_t pm_errno;
+/** Returns the current error code from the handle. */
+enum _alpm_errno_t alpm_errno(alpm_handle_t *handle);
/** Returns the string corresponding to an error number. */
-const char *alpm_strerror(int err);
-
-/** Returns the string corresponding to pm_errno. */
-const char *alpm_strerrorlast(void);
+const char *alpm_strerror(enum _alpm_errno_t err);
/* End of alpm_api_errors */
/** @} */
+alpm_handle_t *alpm_initialize(const char *root, const char *dbpath,
+ enum _alpm_errno_t *err);
+int alpm_release(alpm_handle_t *handle);
+const char *alpm_version(void);
+
/* End of alpm_api */
/** @} */
diff --git a/lib/libalpm/alpm_list.c b/lib/libalpm/alpm_list.c
index 42ef367a..83b9824c 100644
--- a/lib/libalpm/alpm_list.c
+++ b/lib/libalpm/alpm_list.c
@@ -20,7 +20,6 @@
#include <stdlib.h>
#include <string.h>
-#include <stdio.h>
/* libalpm */
#include "alpm_list.h"
@@ -92,7 +91,7 @@ alpm_list_t SYMEXPORT *alpm_list_add(alpm_list_t *list, void *data)
ptr = calloc(1, sizeof(alpm_list_t));
if(ptr == NULL) {
- return(list);
+ return list;
}
ptr->data = data;
@@ -101,7 +100,7 @@ alpm_list_t SYMEXPORT *alpm_list_add(alpm_list_t *list, void *data)
/* Special case: the input list is empty */
if(list == NULL) {
ptr->prev = ptr;
- return(ptr);
+ return ptr;
}
lp = alpm_list_last(list);
@@ -109,7 +108,7 @@ alpm_list_t SYMEXPORT *alpm_list_add(alpm_list_t *list, void *data)
ptr->prev = lp;
list->prev = ptr;
- return(list);
+ return list;
}
/**
@@ -124,13 +123,13 @@ alpm_list_t SYMEXPORT *alpm_list_add(alpm_list_t *list, void *data)
alpm_list_t SYMEXPORT *alpm_list_add_sorted(alpm_list_t *list, void *data, alpm_list_fn_cmp fn)
{
if(!fn || !list) {
- return(alpm_list_add(list, data));
+ return alpm_list_add(list, data);
} else {
alpm_list_t *add = NULL, *prev = NULL, *next = list;
add = calloc(1, sizeof(alpm_list_t));
if(add == NULL) {
- return(list);
+ return list;
}
add->data = data;
@@ -146,19 +145,19 @@ alpm_list_t SYMEXPORT *alpm_list_add_sorted(alpm_list_t *list, void *data, alpm_
add->prev = list->prev; /* list != NULL */
add->next = list;
list->prev = add;
- return(add);
+ return add;
} else if(next == NULL) { /* another special case: add last element */
add->prev = prev;
add->next = NULL;
prev->next = add;
list->prev = add;
- return(list);
+ return list;
} else {
add->prev = prev;
add->next = next;
next->prev = add;
prev->next = add;
- return(list);
+ return list;
}
}
}
@@ -178,11 +177,11 @@ alpm_list_t SYMEXPORT *alpm_list_join(alpm_list_t *first, alpm_list_t *second)
{
alpm_list_t *tmp;
- if (first == NULL) {
- return(second);
+ if(first == NULL) {
+ return second;
}
- if (second == NULL) {
- return(first);
+ if(second == NULL) {
+ return first;
}
/* tmp is the last element of the first list */
tmp = first->prev;
@@ -193,7 +192,7 @@ alpm_list_t SYMEXPORT *alpm_list_join(alpm_list_t *first, alpm_list_t *second)
/* set the back reference to the tail */
second->prev = tmp;
- return(first);
+ return first;
}
/**
@@ -209,12 +208,12 @@ alpm_list_t SYMEXPORT *alpm_list_mmerge(alpm_list_t *left, alpm_list_t *right, a
{
alpm_list_t *newlist, *lp;
- if (left == NULL)
+ if(left == NULL)
return right;
- if (right == NULL)
+ if(right == NULL)
return left;
- if (fn(left->data, right->data) <= 0) {
+ if(fn(left->data, right->data) <= 0) {
newlist = left;
left = left->next;
}
@@ -226,8 +225,8 @@ alpm_list_t SYMEXPORT *alpm_list_mmerge(alpm_list_t *left, alpm_list_t *right, a
newlist->next = NULL;
lp = newlist;
- while ((left != NULL) && (right != NULL)) {
- if (fn(left->data, right->data) <= 0) {
+ while((left != NULL) && (right != NULL)) {
+ if(fn(left->data, right->data) <= 0) {
lp->next = left;
left->prev = lp;
left = left->next;
@@ -240,11 +239,11 @@ alpm_list_t SYMEXPORT *alpm_list_mmerge(alpm_list_t *left, alpm_list_t *right, a
lp = lp->next;
lp->next = NULL;
}
- if (left != NULL) {
+ if(left != NULL) {
lp->next = left;
left->prev = lp;
}
- else if (right != NULL) {
+ else if(right != NULL) {
lp->next = right;
right->prev = lp;
}
@@ -257,7 +256,7 @@ alpm_list_t SYMEXPORT *alpm_list_mmerge(alpm_list_t *left, alpm_list_t *right, a
}
newlist->prev = lp;
- return(newlist);
+ return newlist;
}
/**
@@ -271,7 +270,7 @@ alpm_list_t SYMEXPORT *alpm_list_mmerge(alpm_list_t *left, alpm_list_t *right, a
*/
alpm_list_t SYMEXPORT *alpm_list_msort(alpm_list_t *list, size_t n, alpm_list_fn_cmp fn)
{
- if (n > 1) {
+ if(n > 1) {
alpm_list_t *left = list;
alpm_list_t *lastleft = alpm_list_nth(list, n/2 - 1);
alpm_list_t *right = lastleft->next;
@@ -282,7 +281,7 @@ alpm_list_t SYMEXPORT *alpm_list_msort(alpm_list_t *list, size_t n, alpm_list_fn
right = alpm_list_msort(right, n - (n/2), fn);
list = alpm_list_mmerge(left, right, fn);
}
- return(list);
+ return list;
}
/**
@@ -298,7 +297,7 @@ alpm_list_t SYMEXPORT *alpm_list_remove_item(alpm_list_t *haystack,
alpm_list_t *item)
{
if(haystack == NULL || item == NULL) {
- return(haystack);
+ return haystack;
}
if(item == haystack) {
@@ -328,7 +327,7 @@ alpm_list_t SYMEXPORT *alpm_list_remove_item(alpm_list_t *haystack,
}
}
- return(haystack);
+ return haystack;
}
@@ -352,7 +351,7 @@ alpm_list_t SYMEXPORT *alpm_list_remove(alpm_list_t *haystack,
}
if(needle == NULL) {
- return(haystack);
+ return haystack;
}
while(i) {
@@ -373,7 +372,7 @@ alpm_list_t SYMEXPORT *alpm_list_remove(alpm_list_t *haystack,
}
}
- return(haystack);
+ return haystack;
}
/**
@@ -388,8 +387,8 @@ alpm_list_t SYMEXPORT *alpm_list_remove(alpm_list_t *haystack,
alpm_list_t SYMEXPORT *alpm_list_remove_str(alpm_list_t *haystack,
const char *needle, char **data)
{
- return(alpm_list_remove(haystack, (const void *)needle,
- (alpm_list_fn_cmp)strcmp, (void **)data));
+ return alpm_list_remove(haystack, (const void *)needle,
+ (alpm_list_fn_cmp)strcmp, (void **)data);
}
/**
@@ -411,7 +410,7 @@ alpm_list_t SYMEXPORT *alpm_list_remove_dupes(const alpm_list_t *list)
}
lp = lp->next;
}
- return(newlist);
+ return newlist;
}
/**
@@ -429,7 +428,7 @@ alpm_list_t SYMEXPORT *alpm_list_strdup(const alpm_list_t *list)
newlist = alpm_list_add(newlist, strdup(lp->data));
lp = lp->next;
}
- return(newlist);
+ return newlist;
}
/**
@@ -447,7 +446,7 @@ alpm_list_t SYMEXPORT *alpm_list_copy(const alpm_list_t *list)
newlist = alpm_list_add(newlist, lp->data);
lp = lp->next;
}
- return(newlist);
+ return newlist;
}
/**
@@ -473,7 +472,7 @@ alpm_list_t SYMEXPORT *alpm_list_copy_data(const alpm_list_t *list,
lp = lp->next;
}
}
- return(newlist);
+ return newlist;
}
/**
@@ -489,7 +488,7 @@ alpm_list_t SYMEXPORT *alpm_list_reverse(alpm_list_t *list)
alpm_list_t *newlist = NULL, *backup;
if(list == NULL) {
- return(NULL);
+ return NULL;
}
lp = alpm_list_last(list);
@@ -502,28 +501,12 @@ alpm_list_t SYMEXPORT *alpm_list_reverse(alpm_list_t *list)
lp = lp->prev;
}
list->prev = backup; /* restore tail pointer */
- return(newlist);
+ return newlist;
}
/* Accessors */
/**
- * @brief Get the first element of a list.
- *
- * @param list the list
- *
- * @return the first element in the list
- */
-inline alpm_list_t SYMEXPORT *alpm_list_first(const alpm_list_t *list)
-{
- if(list) {
- return((alpm_list_t*)list);
- } else {
- return(NULL);
- }
-}
-
-/**
* @brief Return nth element from list (starting from 0).
*
* @param list the list
@@ -537,7 +520,7 @@ alpm_list_t SYMEXPORT *alpm_list_nth(const alpm_list_t *list, size_t n)
while(n--) {
i = i->next;
}
- return((alpm_list_t*)i);
+ return (alpm_list_t *)i;
}
/**
@@ -550,9 +533,26 @@ alpm_list_t SYMEXPORT *alpm_list_nth(const alpm_list_t *list, size_t n)
inline alpm_list_t SYMEXPORT *alpm_list_next(const alpm_list_t *node)
{
if(node) {
- return(node->next);
+ return node->next;
} else {
- return(NULL);
+ return NULL;
+ }
+}
+
+/**
+ * @brief Get the previous element of a list.
+ *
+ * @param list the list head
+ * @param node the list node
+ *
+ * @return the previous element, or NULL when no previous element exist
+ */
+inline alpm_list_t SYMEXPORT *alpm_list_previous(const alpm_list_t *list)
+{
+ if(list && list->prev->next) {
+ return list->prev;
+ } else {
+ return NULL;
}
}
@@ -566,9 +566,9 @@ inline alpm_list_t SYMEXPORT *alpm_list_next(const alpm_list_t *node)
alpm_list_t SYMEXPORT *alpm_list_last(const alpm_list_t *list)
{
if(list) {
- return(list->prev);
+ return list->prev;
} else {
- return(NULL);
+ return NULL;
}
}
@@ -581,8 +581,8 @@ alpm_list_t SYMEXPORT *alpm_list_last(const alpm_list_t *list)
*/
void SYMEXPORT *alpm_list_getdata(const alpm_list_t *node)
{
- if(node == NULL) return(NULL);
- return(node->data);
+ if(node == NULL) return NULL;
+ return node->data;
}
/* Misc */
@@ -602,7 +602,7 @@ size_t SYMEXPORT alpm_list_count(const alpm_list_t *list)
++i;
lp = lp->next;
}
- return(i);
+ return i;
}
/**
@@ -620,17 +620,17 @@ void SYMEXPORT *alpm_list_find(const alpm_list_t *haystack, const void *needle,
const alpm_list_t *lp = haystack;
while(lp) {
if(lp->data && fn(lp->data, needle) == 0) {
- return(lp->data);
+ return lp->data;
}
lp = lp->next;
}
- return(NULL);
+ return NULL;
}
/* trivial helper function for alpm_list_find_ptr */
static int ptr_cmp(const void *p, const void *q)
{
- return(p != q);
+ return (p != q);
}
/**
@@ -643,9 +643,10 @@ static int ptr_cmp(const void *p, const void *q)
*
* @return `needle` if found, NULL otherwise
*/
-void SYMEXPORT *alpm_list_find_ptr(const alpm_list_t *haystack, const void *needle)
+void SYMEXPORT *alpm_list_find_ptr(const alpm_list_t *haystack,
+ const void *needle)
{
- return(alpm_list_find(haystack, needle, ptr_cmp));
+ return alpm_list_find(haystack, needle, ptr_cmp);
}
/**
@@ -659,8 +660,8 @@ void SYMEXPORT *alpm_list_find_ptr(const alpm_list_t *haystack, const void *need
char SYMEXPORT *alpm_list_find_str(const alpm_list_t *haystack,
const char *needle)
{
- return((char *)alpm_list_find(haystack, (const void*)needle,
- (alpm_list_fn_cmp)strcmp));
+ return (char *)alpm_list_find(haystack, (const void *)needle,
+ (alpm_list_fn_cmp)strcmp);
}
/**
@@ -688,7 +689,7 @@ void SYMEXPORT alpm_list_diff_sorted(const alpm_list_t *left,
return;
}
- while (l != NULL && r != NULL) {
+ while(l != NULL && r != NULL) {
int cmp = fn(l->data, r->data);
if(cmp < 0) {
if(onlyleft) {
@@ -706,13 +707,13 @@ void SYMEXPORT alpm_list_diff_sorted(const alpm_list_t *left,
r = r->next;
}
}
- while (l != NULL) {
+ while(l != NULL) {
if(onlyleft) {
*onlyleft = alpm_list_add(*onlyleft, l->data);
}
l = l->next;
}
- while (r != NULL) {
+ while(r != NULL) {
if(onlyright) {
*onlyright = alpm_list_add(*onlyright, r->data);
}
@@ -745,7 +746,39 @@ alpm_list_t SYMEXPORT *alpm_list_diff(const alpm_list_t *lhs,
alpm_list_free(left);
alpm_list_free(right);
- return(ret);
+ return ret;
+}
+
+/**
+ * @brief Copy a list and data into a standard C array of fixed length.
+ * Note that the data elements are shallow copied so any contained pointers
+ * will point to the original data.
+ *
+ * @param list the list to copy
+ * @param n the size of the list
+ * @param size the size of each data element
+ *
+ * @return an array version of the original list, data copied as well
+ */
+void SYMEXPORT *alpm_list_to_array(const alpm_list_t *list, size_t n,
+ size_t size)
+{
+ size_t i;
+ const alpm_list_t *item;
+ char *array;
+
+ if(n == 0) {
+ return NULL;
+ }
+
+ array = calloc(n, size);
+ if(array == NULL) {
+ return NULL;
+ }
+ for(i = 0, item = list; i < n && item; i++, item = item->next) {
+ memcpy(array + i * size, item->data, size);
+ }
+ return array;
}
/** @} */
diff --git a/lib/libalpm/alpm_list.h b/lib/libalpm/alpm_list.h
index 1f6393a6..cd7b0291 100644
--- a/lib/libalpm/alpm_list.h
+++ b/lib/libalpm/alpm_list.h
@@ -67,9 +67,9 @@ alpm_list_t *alpm_list_copy_data(const alpm_list_t *list, size_t size);
alpm_list_t *alpm_list_reverse(alpm_list_t *list);
/* item accessors */
-alpm_list_t *alpm_list_first(const alpm_list_t *list);
alpm_list_t *alpm_list_nth(const alpm_list_t *list, size_t n);
alpm_list_t *alpm_list_next(const alpm_list_t *list);
+alpm_list_t *alpm_list_previous(const alpm_list_t *list);
alpm_list_t *alpm_list_last(const alpm_list_t *list);
void *alpm_list_getdata(const alpm_list_t *entry);
@@ -81,6 +81,7 @@ char *alpm_list_find_str(const alpm_list_t *haystack, const char *needle);
alpm_list_t *alpm_list_diff(const alpm_list_t *lhs, const alpm_list_t *rhs, alpm_list_fn_cmp fn);
void alpm_list_diff_sorted(const alpm_list_t *left, const alpm_list_t *right,
alpm_list_fn_cmp fn, alpm_list_t **onlyleft, alpm_list_t **onlyright);
+void *alpm_list_to_array(const alpm_list_t *list, size_t n, size_t size);
#ifdef __cplusplus
}
diff --git a/lib/libalpm/backup.c b/lib/libalpm/backup.c
index ca955ca4..728c1d05 100644
--- a/lib/libalpm/backup.c
+++ b/lib/libalpm/backup.c
@@ -32,82 +32,67 @@
#include "log.h"
#include "util.h"
-/* split a backup string "file\thash" into two strings : file and hash */
-static int backup_split(const char *string, char **file, char **hash)
+/* split a backup string "file\thash" into the relevant components */
+int _alpm_split_backup(const char *string, alpm_backup_t **backup)
{
- char *str = strdup(string);
- char *ptr;
+ char *str, *ptr;
+
+ STRDUP(str, string, return -1);
/* tab delimiter */
- ptr = strchr(str, '\t');
+ ptr = str ? strchr(str, '\t') : NULL;
if(ptr == NULL) {
- if(file) {
- *file = str;
- } else {
- /* don't need our dup as the fname wasn't requested, so free it */
- FREE(str);
- }
- return(0);
+ (*backup)->name = str;
+ (*backup)->hash = NULL;
+ return 0;
}
*ptr = '\0';
ptr++;
/* now str points to the filename and ptr points to the hash */
- if(file) {
- *file = strdup(str);
- }
- if(hash) {
- *hash = strdup(ptr);
- }
+ STRDUP((*backup)->name, str, return -1);
+ STRDUP((*backup)->hash, ptr, return -1);
FREE(str);
- return(1);
-}
-
-char *_alpm_backup_file(const char *string)
-{
- char *file = NULL;
- backup_split(string, &file, NULL);
- return(file);
-}
-
-char *_alpm_backup_hash(const char *string)
-{
- char *hash = NULL;
- backup_split(string, NULL, &hash);
- return(hash);
+ return 0;
}
-/* Look for a filename in a pmpkg_t.backup list. If we find it,
- * then we return the md5 hash (parsed from the same line)
+/* Look for a filename in a alpm_pkg_t.backup list. If we find it,
+ * then we return the full backup entry.
*/
-char *_alpm_needbackup(const char *file, const alpm_list_t *backup)
+alpm_backup_t *_alpm_needbackup(const char *file, alpm_pkg_t *pkg)
{
const alpm_list_t *lp;
- ALPM_LOG_FUNC;
-
- if(file == NULL || backup == NULL) {
- return(NULL);
+ if(file == NULL || pkg == NULL) {
+ return NULL;
}
- /* run through the backup list and parse out the hash for our file */
- for(lp = backup; lp; lp = lp->next) {
- char *filename = NULL;
- char *hash = NULL;
+ for(lp = alpm_pkg_get_backup(pkg); lp; lp = lp->next) {
+ alpm_backup_t *backup = lp->data;
- /* no hash found */
- if(!backup_split((char *)lp->data, &filename, &hash)) {
- FREE(filename);
- continue;
- }
- if(strcmp(file, filename) == 0) {
- FREE(filename);
- return(hash);
+ if(strcmp(file, backup->name) == 0) {
+ return backup;
}
- FREE(filename);
- FREE(hash);
}
- return(NULL);
+ return NULL;
+}
+
+void _alpm_backup_free(alpm_backup_t *backup)
+{
+ free(backup->name);
+ free(backup->hash);
+ free(backup);
+}
+
+alpm_backup_t *_alpm_backup_dup(const alpm_backup_t *backup)
+{
+ alpm_backup_t *newbackup;
+ CALLOC(newbackup, 1, sizeof(alpm_backup_t), return NULL);
+
+ STRDUP(newbackup->name, backup->name, return NULL);
+ STRDUP(newbackup->hash, backup->hash, return NULL);
+
+ return newbackup;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/backup.h b/lib/libalpm/backup.h
index 9475aa2a..0b84a68c 100644
--- a/lib/libalpm/backup.h
+++ b/lib/libalpm/backup.h
@@ -21,10 +21,12 @@
#define _ALPM_BACKUP_H
#include "alpm_list.h"
+#include "alpm.h"
-char *_alpm_backup_file(const char *string);
-char *_alpm_backup_hash(const char *string);
-char *_alpm_needbackup(const char *file, const alpm_list_t *backup);
+int _alpm_split_backup(const char *string, alpm_backup_t **backup);
+alpm_backup_t *_alpm_needbackup(const char *file, alpm_pkg_t *pkg);
+void _alpm_backup_free(alpm_backup_t *backup);
+alpm_backup_t *_alpm_backup_dup(const alpm_backup_t *backup);
#endif /* _ALPM_BACKUP_H */
diff --git a/lib/libalpm/base64.c b/lib/libalpm/base64.c
new file mode 100644
index 00000000..fa8bec5c
--- /dev/null
+++ b/lib/libalpm/base64.c
@@ -0,0 +1,190 @@
+/*
+ * RFC 1521 base64 encoding/decoding
+ *
+ * Copyright (C) 2006-2010, Brainspark B.V.
+ *
+ * This file is part of PolarSSL (http://www.polarssl.org)
+ * Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
+ *
+ * All rights reserved.
+ *
+ * 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/>.
+ */
+/*
+ * Pacman Notes:
+ *
+ * Taken from the PolarSSL project at www.polarssl.org under terms of the
+ * GPL. This is from version 0.14.2 of the library, and has been modified
+ * as following, which may be helpful for future updates:
+ * * remove "polarssl/config.h" include
+ * * change include from "polarssl/base64.h" to "base64.h"
+ * * removal of SELF_TEST code
+ */
+
+#include "base64.h"
+
+static const unsigned char base64_enc_map[64] =
+{
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+ 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
+ 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
+ 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+ 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
+ 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', '+', '/'
+};
+
+static const unsigned char base64_dec_map[128] =
+{
+ 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
+ 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
+ 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
+ 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
+ 127, 127, 127, 62, 127, 127, 127, 63, 52, 53,
+ 54, 55, 56, 57, 58, 59, 60, 61, 127, 127,
+ 127, 64, 127, 127, 127, 0, 1, 2, 3, 4,
+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+ 25, 127, 127, 127, 127, 127, 127, 26, 27, 28,
+ 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
+ 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+ 49, 50, 51, 127, 127, 127, 127, 127
+};
+
+/*
+ * Encode a buffer into base64 format
+ */
+int base64_encode( unsigned char *dst, int *dlen,
+ const unsigned char *src, int slen )
+{
+ int i, n;
+ int C1, C2, C3;
+ unsigned char *p;
+
+ if( slen == 0 )
+ return( 0 );
+
+ n = (slen << 3) / 6;
+
+ switch( (slen << 3) - (n * 6) )
+ {
+ case 2: n += 3; break;
+ case 4: n += 2; break;
+ default: break;
+ }
+
+ if( *dlen < n + 1 )
+ {
+ *dlen = n + 1;
+ return( POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL );
+ }
+
+ n = (slen / 3) * 3;
+
+ for( i = 0, p = dst; i < n; i += 3 )
+ {
+ C1 = *src++;
+ C2 = *src++;
+ C3 = *src++;
+
+ *p++ = base64_enc_map[(C1 >> 2) & 0x3F];
+ *p++ = base64_enc_map[(((C1 & 3) << 4) + (C2 >> 4)) & 0x3F];
+ *p++ = base64_enc_map[(((C2 & 15) << 2) + (C3 >> 6)) & 0x3F];
+ *p++ = base64_enc_map[C3 & 0x3F];
+ }
+
+ if( i < slen )
+ {
+ C1 = *src++;
+ C2 = ((i + 1) < slen) ? *src++ : 0;
+
+ *p++ = base64_enc_map[(C1 >> 2) & 0x3F];
+ *p++ = base64_enc_map[(((C1 & 3) << 4) + (C2 >> 4)) & 0x3F];
+
+ if( (i + 1) < slen )
+ *p++ = base64_enc_map[((C2 & 15) << 2) & 0x3F];
+ else *p++ = '=';
+
+ *p++ = '=';
+ }
+
+ *dlen = p - dst;
+ *p = 0;
+
+ return( 0 );
+}
+
+/*
+ * Decode a base64-formatted buffer
+ */
+int base64_decode( unsigned char *dst, int *dlen,
+ const unsigned char *src, int slen )
+{
+ int i, j, n;
+ unsigned long x;
+ unsigned char *p;
+
+ for( i = j = n = 0; i < slen; i++ )
+ {
+ if( ( slen - i ) >= 2 &&
+ src[i] == '\r' && src[i + 1] == '\n' )
+ continue;
+
+ if( src[i] == '\n' )
+ continue;
+
+ if( src[i] == '=' && ++j > 2 )
+ return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
+
+ if( src[i] > 127 || base64_dec_map[src[i]] == 127 )
+ return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
+
+ if( base64_dec_map[src[i]] < 64 && j != 0 )
+ return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
+
+ n++;
+ }
+
+ if( n == 0 )
+ return( 0 );
+
+ n = ((n * 6) + 7) >> 3;
+
+ if( *dlen < n )
+ {
+ *dlen = n;
+ return( POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL );
+ }
+
+ for( j = 3, n = x = 0, p = dst; i > 0; i--, src++ )
+ {
+ if( *src == '\r' || *src == '\n' )
+ continue;
+
+ j -= ( base64_dec_map[*src] == 64 );
+ x = (x << 6) | ( base64_dec_map[*src] & 0x3F );
+
+ if( ++n == 4 )
+ {
+ n = 0;
+ if( j > 0 ) *p++ = (unsigned char)( x >> 16 );
+ if( j > 1 ) *p++ = (unsigned char)( x >> 8 );
+ if( j > 2 ) *p++ = (unsigned char)( x );
+ }
+ }
+
+ *dlen = p - dst;
+
+ return( 0 );
+}
diff --git a/lib/libalpm/base64.h b/lib/libalpm/base64.h
new file mode 100644
index 00000000..0ae9612c
--- /dev/null
+++ b/lib/libalpm/base64.h
@@ -0,0 +1,68 @@
+/**
+ * \file base64.h
+ *
+ * Copyright (C) 2006-2010, Brainspark B.V.
+ *
+ * This file is part of PolarSSL (http://www.polarssl.org)
+ * Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
+ *
+ * All rights reserved.
+ *
+ * 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/>.
+ */
+
+#ifndef _BASE64_H
+#define _BASE64_H
+
+#define POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL 0x0010
+#define POLARSSL_ERR_BASE64_INVALID_CHARACTER 0x0012
+
+/**
+ * \brief Encode a buffer into base64 format
+ *
+ * \param dst destination buffer
+ * \param dlen size of the buffer
+ * \param src source buffer
+ * \param slen amount of data to be encoded
+ *
+ * \return 0 if successful, or POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL.
+ * *dlen is always updated to reflect the amount
+ * of data that has (or would have) been written.
+ *
+ * \note Call this function with *dlen = 0 to obtain the
+ * required buffer size in *dlen
+ */
+int base64_encode( unsigned char *dst, int *dlen,
+ const unsigned char *src, int slen );
+
+/**
+ * \brief Decode a base64-formatted buffer
+ *
+ * \param dst destination buffer
+ * \param dlen size of the buffer
+ * \param src source buffer
+ * \param slen amount of data to be decoded
+ *
+ * \return 0 if successful, POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL, or
+ * POLARSSL_ERR_BASE64_INVALID_DATA if the input data is not
+ * correct. *dlen is always updated to reflect the amount
+ * of data that has (or would have) been written.
+ *
+ * \note Call this function with *dlen = 0 to obtain the
+ * required buffer size in *dlen
+ */
+int base64_decode( unsigned char *dst, int *dlen,
+ const unsigned char *src, int slen );
+
+#endif /* base64.h */
diff --git a/lib/libalpm/be_local.c b/lib/libalpm/be_local.c
index d5edf34c..5d136c9e 100644
--- a/lib/libalpm/be_local.c
+++ b/lib/libalpm/be_local.c
@@ -1,5 +1,5 @@
/*
- * be_local.c
+ * be_local.c : backend for the local database
*
* Copyright (c) 2006-2011 Pacman Development Team <pacman-dev@archlinux.org>
* Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
@@ -31,10 +31,6 @@
#include <time.h>
#include <limits.h> /* PATH_MAX */
-/* libarchive */
-#include <archive.h>
-#include <archive_entry.h>
-
/* libalpm */
#include "db.h"
#include "alpm_list.h"
@@ -43,18 +39,14 @@
#include "alpm.h"
#include "handle.h"
#include "package.h"
-#include "group.h"
#include "deps.h"
-#include "dload.h"
+static int local_db_read(alpm_pkg_t *info, alpm_dbinfrq_t inforeq);
#define LAZY_LOAD(info, errret) \
do { \
- ALPM_LOG_FUNC; \
- ASSERT(handle != NULL, return(errret)); \
- ASSERT(pkg != NULL, return(errret)); \
- if(pkg->origin != PKG_FROM_FILE && !(pkg->infolevel & info)) { \
- _alpm_local_db_read(pkg->origin_data.db, pkg, info); \
+ if(!(pkg->infolevel & info)) { \
+ local_db_read(pkg, info); \
} \
} while(0)
@@ -65,173 +57,135 @@
* initialized.
*/
-static const char *_cache_get_filename(pmpkg_t *pkg)
+static const char *_cache_get_filename(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, NULL);
return pkg->filename;
}
-static const char *_cache_get_name(pmpkg_t *pkg)
-{
- ASSERT(pkg != NULL, return(NULL));
- return pkg->name;
-}
-
-static const char *_cache_get_version(pmpkg_t *pkg)
-{
- ASSERT(pkg != NULL, return(NULL));
- return pkg->version;
-}
-
-static const char *_cache_get_desc(pmpkg_t *pkg)
+static const char *_cache_get_desc(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, NULL);
return pkg->desc;
}
-static const char *_cache_get_url(pmpkg_t *pkg)
+static const char *_cache_get_url(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, NULL);
return pkg->url;
}
-static time_t _cache_get_builddate(pmpkg_t *pkg)
+static time_t _cache_get_builddate(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, 0);
return pkg->builddate;
}
-static time_t _cache_get_installdate(pmpkg_t *pkg)
+static time_t _cache_get_installdate(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, 0);
return pkg->installdate;
}
-static const char *_cache_get_packager(pmpkg_t *pkg)
+static const char *_cache_get_packager(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, NULL);
return pkg->packager;
}
-static const char *_cache_get_md5sum(pmpkg_t *pkg)
+static const char *_cache_get_md5sum(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, NULL);
return pkg->md5sum;
}
-static const char *_cache_get_arch(pmpkg_t *pkg)
+static const char *_cache_get_arch(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, NULL);
return pkg->arch;
}
-static off_t _cache_get_size(pmpkg_t *pkg)
+static off_t _cache_get_size(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, -1);
return pkg->size;
}
-static off_t _cache_get_isize(pmpkg_t *pkg)
+static off_t _cache_get_isize(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, -1);
return pkg->isize;
}
-static pmpkgreason_t _cache_get_reason(pmpkg_t *pkg)
+static alpm_pkgreason_t _cache_get_reason(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, -1);
return pkg->reason;
}
-static alpm_list_t *_cache_get_licenses(pmpkg_t *pkg)
+static alpm_list_t *_cache_get_licenses(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, NULL);
return pkg->licenses;
}
-static alpm_list_t *_cache_get_groups(pmpkg_t *pkg)
+static alpm_list_t *_cache_get_groups(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, NULL);
return pkg->groups;
}
-static int _cache_has_scriptlet(pmpkg_t *pkg)
+static int _cache_has_scriptlet(alpm_pkg_t *pkg)
{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(-1));
- ASSERT(pkg != NULL, return(-1));
-
- if(!(pkg->infolevel & INFRQ_SCRIPTLET)) {
- _alpm_local_db_read(pkg->origin_data.db, pkg, INFRQ_SCRIPTLET);
- }
+ LAZY_LOAD(INFRQ_SCRIPTLET, NULL);
return pkg->scriptlet;
}
-static alpm_list_t *_cache_get_depends(pmpkg_t *pkg)
+static alpm_list_t *_cache_get_depends(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, NULL);
return pkg->depends;
}
-static alpm_list_t *_cache_get_optdepends(pmpkg_t *pkg)
+static alpm_list_t *_cache_get_optdepends(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, NULL);
return pkg->optdepends;
}
-static alpm_list_t *_cache_get_conflicts(pmpkg_t *pkg)
+static alpm_list_t *_cache_get_conflicts(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, NULL);
return pkg->conflicts;
}
-static alpm_list_t *_cache_get_provides(pmpkg_t *pkg)
+static alpm_list_t *_cache_get_provides(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, NULL);
return pkg->provides;
}
-static alpm_list_t *_cache_get_replaces(pmpkg_t *pkg)
+static alpm_list_t *_cache_get_replaces(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, NULL);
return pkg->replaces;
}
/* local packages can not have deltas */
-static alpm_list_t *_cache_get_deltas(pmpkg_t *pkg)
+static alpm_list_t *_cache_get_deltas(alpm_pkg_t UNUSED *pkg)
{
return NULL;
}
-static alpm_list_t *_cache_get_files(pmpkg_t *pkg)
+static alpm_filelist_t *_cache_get_files(alpm_pkg_t *pkg)
{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(pkg != NULL, return(NULL));
-
- if(pkg->origin == PKG_FROM_LOCALDB
- && !(pkg->infolevel & INFRQ_FILES)) {
- _alpm_local_db_read(pkg->origin_data.db, pkg, INFRQ_FILES);
- }
- return pkg->files;
+ LAZY_LOAD(INFRQ_FILES, NULL);
+ return &(pkg->files);
}
-static alpm_list_t *_cache_get_backup(pmpkg_t *pkg)
+static alpm_list_t *_cache_get_backup(alpm_pkg_t *pkg)
{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(pkg != NULL, return(NULL));
-
- if(pkg->origin == PKG_FROM_LOCALDB
- && !(pkg->infolevel & INFRQ_FILES)) {
- _alpm_local_db_read(pkg->origin_data.db, pkg, INFRQ_FILES);
- }
+ LAZY_LOAD(INFRQ_FILES, NULL);
return pkg->backup;
}
@@ -241,17 +195,11 @@ static alpm_list_t *_cache_get_backup(pmpkg_t *pkg)
* @param pkg the package (from db) to read the changelog
* @return a 'file stream' to the package changelog
*/
-static void *_cache_changelog_open(pmpkg_t *pkg)
+static void *_cache_changelog_open(alpm_pkg_t *pkg)
{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(pkg != NULL, return(NULL));
-
char clfile[PATH_MAX];
snprintf(clfile, PATH_MAX, "%s/%s/%s-%s/changelog",
- alpm_option_get_dbpath(),
+ alpm_option_get_dbpath(pkg->handle),
alpm_db_get_name(alpm_pkg_get_db(pkg)),
alpm_pkg_get_name(pkg),
alpm_pkg_get_version(pkg));
@@ -268,18 +216,11 @@ static void *_cache_changelog_open(pmpkg_t *pkg)
* @return the number of characters read, or 0 if there is no more data
*/
static size_t _cache_changelog_read(void *ptr, size_t size,
- const pmpkg_t *pkg, const void *fp)
+ const alpm_pkg_t UNUSED *pkg, const void *fp)
{
- return ( fread(ptr, 1, size, (FILE*)fp) );
+ return fread(ptr, 1, size, (FILE *)fp);
}
-/*
-static int _cache_changelog_feof(const pmpkg_t *pkg, void *fp)
-{
- return( feof((FILE*)fp) );
-}
-*/
-
/**
* Close a package changelog for reading. Similar to fclose in functionality,
* except that the 'file stream' is from the database.
@@ -287,9 +228,14 @@ static int _cache_changelog_feof(const pmpkg_t *pkg, void *fp)
* @param fp a 'file stream' to the package changelog
* @return whether closing the package changelog stream was successful
*/
-static int _cache_changelog_close(const pmpkg_t *pkg, void *fp)
+static int _cache_changelog_close(const alpm_pkg_t UNUSED *pkg, void *fp)
{
- return( fclose((FILE*)fp) );
+ return fclose((FILE *)fp);
+}
+
+static int _cache_force_load(alpm_pkg_t *pkg)
+{
+ return local_db_read(pkg, INFRQ_ALL);
}
@@ -299,8 +245,6 @@ static int _cache_changelog_close(const pmpkg_t *pkg, void *fp)
*/
static struct pkg_operations local_pkg_ops = {
.get_filename = _cache_get_filename,
- .get_name = _cache_get_name,
- .get_version = _cache_get_version,
.get_desc = _cache_get_desc,
.get_url = _cache_get_url,
.get_builddate = _cache_get_builddate,
@@ -326,33 +270,35 @@ static struct pkg_operations local_pkg_ops = {
.changelog_open = _cache_changelog_open,
.changelog_read = _cache_changelog_read,
.changelog_close = _cache_changelog_close,
+
+ .force_load = _cache_force_load,
};
-static int checkdbdir(pmdb_t *db)
+static int checkdbdir(alpm_db_t *db)
{
struct stat buf;
const char *path = _alpm_db_path(db);
if(stat(path, &buf) != 0) {
- _alpm_log(PM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
path);
if(_alpm_makepath(path) != 0) {
- RET_ERR(PM_ERR_SYSTEM, -1);
+ RET_ERR(db->handle, ALPM_ERR_SYSTEM, -1);
}
} else if(!S_ISDIR(buf.st_mode)) {
- _alpm_log(PM_LOG_WARNING, _("removing invalid database: %s\n"), path);
+ _alpm_log(db->handle, ALPM_LOG_WARNING, _("removing invalid database: %s\n"), path);
if(unlink(path) != 0 || _alpm_makepath(path) != 0) {
- RET_ERR(PM_ERR_SYSTEM, -1);
+ RET_ERR(db->handle, ALPM_ERR_SYSTEM, -1);
}
}
- return(0);
+ return 0;
}
static int is_dir(const char *path, struct dirent *entry)
{
#ifdef HAVE_STRUCT_DIRENT_D_TYPE
if(entry->d_type != DT_UNKNOWN) {
- return(entry->d_type == DT_DIR);
+ return (entry->d_type == DT_DIR);
}
#endif
{
@@ -361,15 +307,71 @@ static int is_dir(const char *path, struct dirent *entry)
snprintf(buffer, PATH_MAX, "%s/%s", path, entry->d_name);
- if (!stat(buffer, &sbuf)) {
- return(S_ISDIR(sbuf.st_mode));
+ if(!stat(buffer, &sbuf)) {
+ return S_ISDIR(sbuf.st_mode);
}
}
- return(0);
+ return 0;
}
-static int local_db_populate(pmdb_t *db)
+static int local_db_validate(alpm_db_t *db)
+{
+ struct dirent *ent = NULL;
+ const char *dbpath;
+ DIR *dbdir;
+ int ret = -1;
+
+ if(db->status & DB_STATUS_VALID) {
+ return 0;
+ }
+
+ dbpath = _alpm_db_path(db);
+ if(dbpath == NULL) {
+ RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
+ }
+ dbdir = opendir(dbpath);
+ if(dbdir == NULL) {
+ if(errno == ENOENT) {
+ /* database dir doesn't exist yet */
+ db->status |= DB_STATUS_VALID;
+ return 0;
+ } else {
+ RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
+ }
+ }
+
+ while((ent = readdir(dbdir)) != NULL) {
+ const char *name = ent->d_name;
+ char path[PATH_MAX];
+
+ if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
+ continue;
+ }
+ if(!is_dir(dbpath, ent)) {
+ continue;
+ }
+
+ snprintf(path, PATH_MAX, "%s%s/depends", dbpath, name);
+ if(access(path, F_OK) == 0) {
+ /* we found a depends file- bail */
+ db->handle->pm_errno = ALPM_ERR_DB_VERSION;
+ goto done;
+ }
+ }
+ /* we found no depends file after full scan */
+ db->status |= DB_STATUS_VALID;
+ ret = 0;
+
+done:
+ if(dbdir) {
+ closedir(dbdir);
+ }
+
+ return ret;
+}
+
+static int local_db_populate(alpm_db_t *db)
{
size_t est_count;
int count = 0;
@@ -378,25 +380,22 @@ static int local_db_populate(pmdb_t *db)
const char *dbpath;
DIR *dbdir;
- ALPM_LOG_FUNC;
-
- ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
-
dbpath = _alpm_db_path(db);
if(dbpath == NULL) {
/* pm_errno set in _alpm_db_path() */
return -1;
}
+
dbdir = opendir(dbpath);
if(dbdir == NULL) {
if(errno == ENOENT) {
/* no database existing yet is not an error */
- return(0);
+ return 0;
}
- RET_ERR(PM_ERR_DB_OPEN, -1);
+ RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
}
if(fstat(dirfd(dbdir), &buf) != 0) {
- RET_ERR(PM_ERR_DB_OPEN, -1);
+ RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
}
if(buf.st_nlink >= 2) {
est_count = buf.st_nlink;
@@ -420,13 +419,13 @@ static int local_db_populate(pmdb_t *db)
db->pkgcache = _alpm_pkghash_create(est_count * 2);
if(db->pkgcache == NULL){
closedir(dbdir);
- RET_ERR(PM_ERR_MEMORY, -1);
+ RET_ERR(db->handle, ALPM_ERR_MEMORY, -1);
}
while((ent = readdir(dbdir)) != NULL) {
const char *name = ent->d_name;
- pmpkg_t *pkg;
+ alpm_pkg_t *pkg;
if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
continue;
@@ -438,11 +437,12 @@ static int local_db_populate(pmdb_t *db)
pkg = _alpm_pkg_new();
if(pkg == NULL) {
closedir(dbdir);
- RET_ERR(PM_ERR_MEMORY, -1);
+ RET_ERR(db->handle, ALPM_ERR_MEMORY, -1);
}
/* split the db entry name */
- if(_alpm_splitname(name, pkg) != 0) {
- _alpm_log(PM_LOG_ERROR, _("invalid name for database entry '%s'\n"),
+ if(_alpm_splitname(name, &(pkg->name), &(pkg->version),
+ &(pkg->name_hash)) != 0) {
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("invalid name for database entry '%s'\n"),
name);
_alpm_pkg_free(pkg);
continue;
@@ -450,7 +450,7 @@ static int local_db_populate(pmdb_t *db)
/* duplicated database entries are not allowed */
if(_alpm_pkghash_find(db->pkgcache, pkg->name)) {
- _alpm_log(PM_LOG_ERROR, _("duplicated database entry '%s'\n"), pkg->name);
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("duplicated database entry '%s'\n"), pkg->name);
_alpm_pkg_free(pkg);
continue;
}
@@ -458,16 +458,17 @@ static int local_db_populate(pmdb_t *db)
pkg->origin = PKG_FROM_LOCALDB;
pkg->origin_data.db = db;
pkg->ops = &local_pkg_ops;
+ pkg->handle = db->handle;
/* explicitly read with only 'BASE' data, accessors will handle the rest */
- if(_alpm_local_db_read(db, pkg, INFRQ_BASE) == -1) {
- _alpm_log(PM_LOG_ERROR, _("corrupted database entry '%s'\n"), name);
+ if(local_db_read(pkg, INFRQ_BASE) == -1) {
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("corrupted database entry '%s'\n"), name);
_alpm_pkg_free(pkg);
continue;
}
/* add to the collection */
- _alpm_log(PM_LOG_DEBUG, "adding '%s' to package cache for db '%s'\n",
+ _alpm_log(db->handle, ALPM_LOG_FUNCTION, "adding '%s' to package cache for db '%s'\n",
pkg->name, db->treename);
db->pkgcache = _alpm_pkghash_add(db->pkgcache, pkg);
count++;
@@ -477,11 +478,14 @@ static int local_db_populate(pmdb_t *db)
if(count > 0) {
db->pkgcache->list = alpm_list_msort(db->pkgcache->list, (size_t)count, _alpm_pkg_cmp);
}
- return(count);
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "added %d packages to package cache for db '%s'\n",
+ count, db->treename);
+
+ return count;
}
/* Note: the return value must be freed by the caller */
-static char *get_pkgpath(pmdb_t *db, pmpkg_t *info)
+static char *get_pkgpath(alpm_db_t *db, alpm_pkg_t *info)
{
size_t len;
char *pkgpath;
@@ -489,36 +493,36 @@ static char *get_pkgpath(pmdb_t *db, pmpkg_t *info)
dbpath = _alpm_db_path(db);
len = strlen(dbpath) + strlen(info->name) + strlen(info->version) + 3;
- MALLOC(pkgpath, len, RET_ERR(PM_ERR_MEMORY, NULL));
+ MALLOC(pkgpath, len, RET_ERR(db->handle, ALPM_ERR_MEMORY, NULL));
sprintf(pkgpath, "%s%s-%s/", dbpath, info->name, info->version);
- return(pkgpath);
+ return pkgpath;
}
+#define READ_NEXT() do { \
+ if(fgets(line, sizeof(line), fp) == NULL && !feof(fp)) goto error; \
+ _alpm_strip_newline(line); \
+} while(0)
+
+#define READ_AND_STORE(f) do { \
+ READ_NEXT(); \
+ STRDUP(f, line, goto error); \
+} while(0)
+
+#define READ_AND_STORE_ALL(f) do { \
+ char *linedup; \
+ if(fgets(line, sizeof(line), fp) == NULL && !feof(fp)) goto error; \
+ if(_alpm_strip_newline(line) == 0) break; \
+ STRDUP(linedup, line, goto error); \
+ f = alpm_list_add(f, linedup); \
+} while(1) /* note the while(1) and not (0) */
-int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
+static int local_db_read(alpm_pkg_t *info, alpm_dbinfrq_t inforeq)
{
FILE *fp = NULL;
char path[PATH_MAX];
char line[1024];
char *pkgpath = NULL;
-
- ALPM_LOG_FUNC;
-
- if(db == NULL) {
- RET_ERR(PM_ERR_DB_NULL, -1);
- }
-
- if(info == NULL || info->name == NULL || info->version == NULL) {
- _alpm_log(PM_LOG_DEBUG, "invalid package entry provided to _alpm_local_db_read, skipping\n");
- return(-1);
- }
-
- if(info->origin != PKG_FROM_LOCALDB) {
- _alpm_log(PM_LOG_DEBUG,
- "request to read info for a non-local package '%s', skipping...\n",
- info->name);
- return(-1);
- }
+ alpm_db_t *db = info->origin_data.db;
/* bitmask logic here:
* infolevel: 00001111
@@ -527,9 +531,16 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
* == to inforeq? nope, we need to load more info. */
if((info->infolevel & inforeq) == inforeq) {
/* already loaded all of this info, do nothing */
- return(0);
+ return 0;
+ }
+
+ if(info->infolevel & INFRQ_ERROR) {
+ /* We've encountered an error loading this package before. Don't attempt
+ * repeated reloads, just give up. */
+ return -1;
}
- _alpm_log(PM_LOG_FUNCTION, "loading package data for %s : level=0x%x\n",
+
+ _alpm_log(db->handle, ALPM_LOG_FUNCTION, "loading package data for %s : level=0x%x\n",
info->name, inforeq);
/* clear out 'line', to be certain - and to make valgrind happy */
@@ -539,7 +550,7 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
if(access(pkgpath, F_OK)) {
/* directory doesn't exist or can't be opened */
- _alpm_log(PM_LOG_DEBUG, "cannot find '%s-%s' in db '%s'\n",
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "cannot find '%s-%s' in db '%s'\n",
info->name, info->version, db->treename);
goto error;
}
@@ -548,151 +559,129 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
if(inforeq & INFRQ_DESC && !(info->infolevel & INFRQ_DESC)) {
snprintf(path, PATH_MAX, "%sdesc", pkgpath);
if((fp = fopen(path, "r")) == NULL) {
- _alpm_log(PM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
goto error;
}
while(!feof(fp)) {
- if(fgets(line, sizeof(line), fp) == NULL) {
- break;
- }
- _alpm_strtrim(line);
+ READ_NEXT();
if(strcmp(line, "%NAME%") == 0) {
- if(fgets(line, sizeof(line), fp) == NULL) {
- goto error;
- }
- if(strcmp(_alpm_strtrim(line), info->name) != 0) {
- _alpm_log(PM_LOG_ERROR, _("%s database is inconsistent: name "
+ READ_NEXT();
+ if(strcmp(line, info->name) != 0) {
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("%s database is inconsistent: name "
"mismatch on package %s\n"), db->treename, info->name);
}
} else if(strcmp(line, "%VERSION%") == 0) {
- if(fgets(line, sizeof(line), fp) == NULL) {
- goto error;
- }
- if(strcmp(_alpm_strtrim(line), info->version) != 0) {
- _alpm_log(PM_LOG_ERROR, _("%s database is inconsistent: version "
+ READ_NEXT();
+ if(strcmp(line, info->version) != 0) {
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("%s database is inconsistent: version "
"mismatch on package %s\n"), db->treename, info->name);
}
} else if(strcmp(line, "%DESC%") == 0) {
- if(fgets(line, sizeof(line), fp) == NULL) {
- goto error;
- }
- STRDUP(info->desc, _alpm_strtrim(line), goto error);
+ READ_AND_STORE(info->desc);
} else if(strcmp(line, "%GROUPS%") == 0) {
- while(fgets(line, sizeof(line), fp) && strlen(_alpm_strtrim(line))) {
- char *linedup;
- STRDUP(linedup, line, goto error);
- info->groups = alpm_list_add(info->groups, linedup);
- }
+ READ_AND_STORE_ALL(info->groups);
} else if(strcmp(line, "%URL%") == 0) {
- if(fgets(line, sizeof(line), fp) == NULL) {
- goto error;
- }
- STRDUP(info->url, _alpm_strtrim(line), goto error);
+ READ_AND_STORE(info->url);
} else if(strcmp(line, "%LICENSE%") == 0) {
- while(fgets(line, sizeof(line), fp) && strlen(_alpm_strtrim(line))) {
- char *linedup;
- STRDUP(linedup, line, goto error);
- info->licenses = alpm_list_add(info->licenses, linedup);
- }
+ READ_AND_STORE_ALL(info->licenses);
} else if(strcmp(line, "%ARCH%") == 0) {
- if(fgets(line, sizeof(line), fp) == NULL) {
- goto error;
- }
- STRDUP(info->arch, _alpm_strtrim(line), goto error);
+ READ_AND_STORE(info->arch);
} else if(strcmp(line, "%BUILDDATE%") == 0) {
- if(fgets(line, sizeof(line), fp) == NULL) {
- goto error;
- }
- _alpm_strtrim(line);
+ READ_NEXT();
info->builddate = _alpm_parsedate(line);
} else if(strcmp(line, "%INSTALLDATE%") == 0) {
- if(fgets(line, sizeof(line), fp) == NULL) {
- goto error;
- }
- _alpm_strtrim(line);
+ READ_NEXT();
info->installdate = _alpm_parsedate(line);
} else if(strcmp(line, "%PACKAGER%") == 0) {
- if(fgets(line, sizeof(line), fp) == NULL) {
- goto error;
- }
- STRDUP(info->packager, _alpm_strtrim(line), goto error);
+ READ_AND_STORE(info->packager);
} else if(strcmp(line, "%REASON%") == 0) {
- if(fgets(line, sizeof(line), fp) == NULL) {
- goto error;
- }
- info->reason = (pmpkgreason_t)atol(_alpm_strtrim(line));
+ READ_NEXT();
+ info->reason = (alpm_pkgreason_t)atol(line);
} else if(strcmp(line, "%SIZE%") == 0) {
/* NOTE: the CSIZE and SIZE fields both share the "size" field
* in the pkginfo_t struct. This can be done b/c CSIZE
* is currently only used in sync databases, and SIZE is
* only used in local databases.
*/
- if(fgets(line, sizeof(line), fp) == NULL) {
- goto error;
- }
- info->size = atol(_alpm_strtrim(line));
+ READ_NEXT();
+ info->size = atol(line);
/* also store this value to isize */
info->isize = info->size;
} else if(strcmp(line, "%REPLACES%") == 0) {
- while(fgets(line, sizeof(line), fp) && strlen(_alpm_strtrim(line))) {
- char *linedup;
- STRDUP(linedup, line, goto error);
- info->replaces = alpm_list_add(info->replaces, linedup);
- }
+ READ_AND_STORE_ALL(info->replaces);
} else if(strcmp(line, "%DEPENDS%") == 0) {
- while(fgets(line, sizeof(line), fp) && strlen(_alpm_strtrim(line))) {
- pmdepend_t *dep = _alpm_splitdep(line);
- info->depends = alpm_list_add(info->depends, dep);
+ /* Different than the rest because of the _alpm_splitdep call. */
+ while(1) {
+ READ_NEXT();
+ if(strlen(line) == 0) break;
+ info->depends = alpm_list_add(info->depends, _alpm_splitdep(line));
}
} else if(strcmp(line, "%OPTDEPENDS%") == 0) {
- while(fgets(line, sizeof(line), fp) && strlen(_alpm_strtrim(line))) {
- char *linedup;
- STRDUP(linedup, line, goto error);
- info->optdepends = alpm_list_add(info->optdepends, linedup);
- }
+ READ_AND_STORE_ALL(info->optdepends);
} else if(strcmp(line, "%CONFLICTS%") == 0) {
- while(fgets(line, sizeof(line), fp) && strlen(_alpm_strtrim(line))) {
- char *linedup;
- STRDUP(linedup, line, goto error);
- info->conflicts = alpm_list_add(info->conflicts, linedup);
- }
+ READ_AND_STORE_ALL(info->conflicts);
} else if(strcmp(line, "%PROVIDES%") == 0) {
- while(fgets(line, sizeof(line), fp) && strlen(_alpm_strtrim(line))) {
- char *linedup;
- STRDUP(linedup, line, goto error);
- info->provides = alpm_list_add(info->provides, linedup);
- }
+ READ_AND_STORE_ALL(info->provides);
}
}
fclose(fp);
fp = NULL;
+ info->infolevel |= INFRQ_DESC;
}
/* FILES */
if(inforeq & INFRQ_FILES && !(info->infolevel & INFRQ_FILES)) {
snprintf(path, PATH_MAX, "%sfiles", pkgpath);
if((fp = fopen(path, "r")) == NULL) {
- _alpm_log(PM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
goto error;
}
while(fgets(line, sizeof(line), fp)) {
- _alpm_strtrim(line);
+ _alpm_strip_newline(line);
if(strcmp(line, "%FILES%") == 0) {
- while(fgets(line, sizeof(line), fp) && strlen(_alpm_strtrim(line))) {
- char *linedup;
- STRDUP(linedup, line, goto error);
- info->files = alpm_list_add(info->files, linedup);
+ size_t files_count = 0, files_size = 0;
+ alpm_file_t *files = NULL;
+
+ while(fgets(line, sizeof(line), fp) && _alpm_strip_newline(line)) {
+ if(files_count >= files_size) {
+ size_t old_size = files_size;
+ if(files_size == 0) {
+ files_size = 8;
+ } else {
+ files_size *= 2;
+ }
+ files = realloc(files, sizeof(alpm_file_t) * files_size);
+ if(!files) {
+ ALLOC_FAIL(sizeof(alpm_file_t) * files_size);
+ goto error;
+ }
+ /* ensure all new memory is zeroed out, in both the initial
+ * allocation and later reallocs */
+ memset(files + old_size, 0,
+ sizeof(alpm_file_t) * (files_size - old_size));
+ }
+ STRDUP(files[files_count].name, line, goto error);
+ /* TODO: lstat file, get mode/size */
+ files_count++;
}
+ /* attempt to hand back any memory we don't need */
+ files = realloc(files, sizeof(alpm_file_t) * files_count);
+ info->files.count = files_count;
+ info->files.files = files;
} else if(strcmp(line, "%BACKUP%") == 0) {
- while(fgets(line, sizeof(line), fp) && strlen(_alpm_strtrim(line))) {
- char *linedup;
- STRDUP(linedup, line, goto error);
- info->backup = alpm_list_add(info->backup, linedup);
+ while(fgets(line, sizeof(line), fp) && _alpm_strip_newline(line)) {
+ alpm_backup_t *backup;
+ CALLOC(backup, 1, sizeof(alpm_backup_t), goto error);
+ if(_alpm_split_backup(line, &backup)) {
+ goto error;
+ }
+ info->backup = alpm_list_add(info->backup, backup);
}
}
}
fclose(fp);
fp = NULL;
+ info->infolevel |= INFRQ_FILES;
}
/* INSTALL */
@@ -701,47 +690,46 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
if(access(path, F_OK) == 0) {
info->scriptlet = 1;
}
+ info->infolevel |= INFRQ_SCRIPTLET;
}
- /* internal */
- info->infolevel |= inforeq;
-
free(pkgpath);
- return(0);
+ return 0;
error:
+ info->infolevel |= INFRQ_ERROR;
free(pkgpath);
if(fp) {
fclose(fp);
}
- return(-1);
+ return -1;
}
-int _alpm_local_db_prepare(pmdb_t *db, pmpkg_t *info)
+int _alpm_local_db_prepare(alpm_db_t *db, alpm_pkg_t *info)
{
mode_t oldmask;
int retval = 0;
char *pkgpath = NULL;
if(checkdbdir(db) != 0) {
- return(-1);
+ return -1;
}
oldmask = umask(0000);
pkgpath = get_pkgpath(db, info);
if((retval = mkdir(pkgpath, 0755)) != 0) {
- _alpm_log(PM_LOG_ERROR, _("could not create directory %s: %s\n"),
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("could not create directory %s: %s\n"),
pkgpath, strerror(errno));
}
free(pkgpath);
umask(oldmask);
- return(retval);
+ return retval;
}
-int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
+int _alpm_local_db_write(alpm_db_t *db, alpm_pkg_t *info, alpm_dbinfrq_t inforeq)
{
FILE *fp = NULL;
char path[PATH_MAX];
@@ -750,10 +738,8 @@ int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
int retval = 0;
char *pkgpath = NULL;
- ALPM_LOG_FUNC;
-
if(db == NULL || info == NULL) {
- return(-1);
+ return -1;
}
pkgpath = get_pkgpath(db, info);
@@ -762,16 +748,17 @@ int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
oldmask = umask(0022);
if(strcmp(db->treename, "local") != 0) {
- return(-1);
+ return -1;
}
/* DESC */
if(inforeq & INFRQ_DESC) {
- _alpm_log(PM_LOG_DEBUG, "writing %s-%s DESC information back to db\n",
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "writing %s-%s DESC information back to db\n",
info->name, info->version);
snprintf(path, PATH_MAX, "%sdesc", pkgpath);
if((fp = fopen(path, "w")) == NULL) {
- _alpm_log(PM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"),
+ path, strerror(errno));
retval = -1;
goto cleanup;
}
@@ -868,25 +855,29 @@ int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
/* FILES */
if(inforeq & INFRQ_FILES) {
- _alpm_log(PM_LOG_DEBUG, "writing %s-%s FILES information back to db\n",
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "writing %s-%s FILES information back to db\n",
info->name, info->version);
snprintf(path, PATH_MAX, "%sfiles", pkgpath);
if((fp = fopen(path, "w")) == NULL) {
- _alpm_log(PM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"),
+ path, strerror(errno));
retval = -1;
goto cleanup;
}
- if(info->files) {
+ if(info->files.count) {
+ size_t i;
fprintf(fp, "%%FILES%%\n");
- for(lp = info->files; lp; lp = lp->next) {
- fprintf(fp, "%s\n", (char *)lp->data);
+ for(i = 0; i < info->files.count; i++) {
+ const alpm_file_t *file = info->files.files + i;
+ fprintf(fp, "%s\n", file->name);
}
fprintf(fp, "\n");
}
if(info->backup) {
fprintf(fp, "%%BACKUP%%\n");
for(lp = info->backup; lp; lp = lp->next) {
- fprintf(fp, "%s\n", (char *)lp->data);
+ const alpm_backup_t *backup = lp->data;
+ fprintf(fp, "%s\t%s\n", backup->name, backup->hash);
}
fprintf(fp, "\n");
}
@@ -905,20 +896,14 @@ cleanup:
fclose(fp);
}
- return(retval);
+ return retval;
}
-int _alpm_local_db_remove(pmdb_t *db, pmpkg_t *info)
+int _alpm_local_db_remove(alpm_db_t *db, alpm_pkg_t *info)
{
int ret = 0;
char *pkgpath = NULL;
- ALPM_LOG_FUNC;
-
- if(db == NULL || info == NULL) {
- RET_ERR(PM_ERR_DB_NULL, -1);
- }
-
pkgpath = get_pkgpath(db, info);
ret = _alpm_rmrf(pkgpath);
@@ -926,83 +911,37 @@ int _alpm_local_db_remove(pmdb_t *db, pmpkg_t *info)
if(ret != 0) {
ret = -1;
}
- return(ret);
-}
-
-static int local_db_version(pmdb_t *db)
-{
- struct dirent *ent = NULL;
- const char *dbpath;
- DIR *dbdir;
- int version;
-
- dbpath = _alpm_db_path(db);
- if(dbpath == NULL) {
- RET_ERR(PM_ERR_DB_OPEN, -1);
- }
- dbdir = opendir(dbpath);
- if(dbdir == NULL) {
- if(errno == ENOENT) {
- /* database dir doesn't exist yet */
- version = 2;
- goto done;
- } else {
- RET_ERR(PM_ERR_DB_OPEN, -1);
- }
- }
-
- while((ent = readdir(dbdir)) != NULL) {
- const char *name = ent->d_name;
- char path[PATH_MAX];
-
- if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
- continue;
- }
- if(!is_dir(dbpath, ent)) {
- continue;
- }
-
- snprintf(path, PATH_MAX, "%s%s/depends", dbpath, name);
- if(access(path, F_OK) == 0) {
- /* we found a depends file- bail */
- version = 1;
- goto done;
- }
- }
- /* we found no depends file after full scan */
- version = 2;
-
-done:
- if(dbdir) {
- closedir(dbdir);
- }
-
- _alpm_log(PM_LOG_DEBUG, "local database version %d\n", version);
- return(version);
+ return ret;
}
struct db_operations local_db_ops = {
+ .validate = local_db_validate,
.populate = local_db_populate,
.unregister = _alpm_db_unregister,
- .version = local_db_version,
};
-pmdb_t *_alpm_db_register_local(void)
+alpm_db_t *_alpm_db_register_local(alpm_handle_t *handle)
{
- pmdb_t *db;
-
- ALPM_LOG_FUNC;
+ alpm_db_t *db;
- _alpm_log(PM_LOG_DEBUG, "registering local database\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "registering local database\n");
db = _alpm_db_new("local", 1);
if(db == NULL) {
- RET_ERR(PM_ERR_DB_CREATE, NULL);
+ handle->pm_errno = ALPM_ERR_DB_CREATE;
+ return NULL;
}
db->ops = &local_db_ops;
+ db->handle = handle;
+
+ if(local_db_validate(db)) {
+ /* pm_errno set in local_db_validate() */
+ _alpm_db_free(db);
+ return NULL;
+ }
handle->db_local = db;
- return(db);
+ return db;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/be_package.c b/lib/libalpm/be_package.c
index 6dfddd61..f80790cd 100644
--- a/lib/libalpm/be_package.c
+++ b/lib/libalpm/be_package.c
@@ -1,5 +1,5 @@
/*
- * be_package.c
+ * be_package.c : backend for packages
*
* Copyright (c) 2006-2011 Pacman Development Team <pacman-dev@archlinux.org>
* Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
@@ -20,10 +20,8 @@
#include "config.h"
-#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <limits.h>
#include <errno.h>
/* libarchive */
@@ -32,8 +30,10 @@
/* libalpm */
#include "alpm_list.h"
+#include "alpm.h"
#include "util.h"
#include "log.h"
+#include "handle.h"
#include "package.h"
#include "deps.h" /* _alpm_splitdep */
@@ -43,40 +43,38 @@
* @param pkg the package (file) to read the changelog
* @return a 'file stream' to the package changelog
*/
-static void *_package_changelog_open(pmpkg_t *pkg)
+static void *_package_changelog_open(alpm_pkg_t *pkg)
{
- ALPM_LOG_FUNC;
-
- ASSERT(pkg != NULL, return(NULL));
+ ASSERT(pkg != NULL, return NULL);
struct archive *archive = NULL;
struct archive_entry *entry;
const char *pkgfile = pkg->origin_data.file;
if((archive = archive_read_new()) == NULL) {
- RET_ERR(PM_ERR_LIBARCHIVE, NULL);
+ RET_ERR(pkg->handle, ALPM_ERR_LIBARCHIVE, NULL);
}
archive_read_support_compression_all(archive);
archive_read_support_format_all(archive);
- if (archive_read_open_filename(archive, pkgfile,
+ if(archive_read_open_filename(archive, pkgfile,
ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
- RET_ERR(PM_ERR_PKG_OPEN, NULL);
+ RET_ERR(pkg->handle, ALPM_ERR_PKG_OPEN, NULL);
}
while(archive_read_next_header(archive, &entry) == ARCHIVE_OK) {
const char *entry_name = archive_entry_pathname(entry);
if(strcmp(entry_name, ".CHANGELOG") == 0) {
- return(archive);
+ return archive;
}
}
/* we didn't find a changelog */
archive_read_finish(archive);
errno = ENOENT;
- return(NULL);
+ return NULL;
}
/**
@@ -89,26 +87,17 @@ static void *_package_changelog_open(pmpkg_t *pkg)
* @return the number of characters read, or 0 if there is no more data
*/
static size_t _package_changelog_read(void *ptr, size_t size,
- const pmpkg_t *pkg, const void *fp)
+ const alpm_pkg_t UNUSED *pkg, const void *fp)
{
- ssize_t sret = archive_read_data((struct archive*)fp, ptr, size);
+ ssize_t sret = archive_read_data((struct archive *)fp, ptr, size);
/* Report error (negative values) */
if(sret < 0) {
- pm_errno = PM_ERR_LIBARCHIVE;
- return(0);
+ RET_ERR(pkg->handle, ALPM_ERR_LIBARCHIVE, 0);
} else {
- return((size_t)sret);
+ return (size_t)sret;
}
}
-/*
-static int _package_changelog_feof(const pmpkg_t *pkg, void *fp)
-{
- // note: this doesn't quite work, no feof in libarchive
- return( archive_read_data((struct archive*)fp, NULL, 0) );
-}
-*/
-
/**
* Close a package changelog for reading. Similar to fclose in functionality,
* except that the 'file stream' is from an archive.
@@ -116,9 +105,9 @@ static int _package_changelog_feof(const pmpkg_t *pkg, void *fp)
* @param fp a 'file stream' to the package changelog
* @return whether closing the package changelog stream was successful
*/
-static int _package_changelog_close(const pmpkg_t *pkg, void *fp)
+static int _package_changelog_close(const alpm_pkg_t UNUSED *pkg, void *fp)
{
- return( archive_read_finish((struct archive *)fp) );
+ return archive_read_finish((struct archive *)fp);
}
/** Package file operations struct accessor. We implement this as a method
@@ -137,72 +126,70 @@ static struct pkg_operations *get_file_pkg_ops(void)
file_pkg_ops.changelog_close = _package_changelog_close;
file_pkg_ops_initialized = 1;
}
- return(&file_pkg_ops);
+ return &file_pkg_ops;
}
/**
- * Parses the package description file for a package into a pmpkg_t struct.
+ * Parses the package description file for a package into a alpm_pkg_t struct.
* @param archive the archive to read from, pointed at the .PKGINFO entry
- * @param newpkg an empty pmpkg_t struct to fill with package info
+ * @param newpkg an empty alpm_pkg_t struct to fill with package info
*
- * @return 0 on success, 1 on error
+ * @return 0 on success, -1 on error
*/
-static int parse_descfile(struct archive *a, pmpkg_t *newpkg)
+static int parse_descfile(alpm_handle_t *handle, struct archive *a, alpm_pkg_t *newpkg)
{
char *ptr = NULL;
char *key = NULL;
- int linenum = 0;
+ int ret, linenum = 0;
struct archive_read_buffer buf;
- ALPM_LOG_FUNC;
-
memset(&buf, 0, sizeof(buf));
/* 512K for a line length seems reasonable */
buf.max_line_size = 512 * 1024;
/* loop until we reach EOF or other error */
- while(_alpm_archive_fgets(a, &buf) == ARCHIVE_OK) {
- char *line = _alpm_strtrim(buf.line);
+ while((ret = _alpm_archive_fgets(a, &buf)) == ARCHIVE_OK) {
+ size_t len = _alpm_strip_newline(buf.line);
linenum++;
- if(strlen(line) == 0 || line[0] == '#') {
+ if(len == 0 || buf.line[0] == '#') {
continue;
}
- ptr = line;
+ ptr = buf.line;
key = strsep(&ptr, "=");
if(key == NULL || ptr == NULL) {
- _alpm_log(PM_LOG_DEBUG, "%s: syntax error in description file line %d\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "%s: syntax error in description file line %d\n",
newpkg->name ? newpkg->name : "error", linenum);
} else {
key = _alpm_strtrim(key);
while(*ptr == ' ') ptr++;
ptr = _alpm_strtrim(ptr);
if(strcmp(key, "pkgname") == 0) {
- STRDUP(newpkg->name, ptr, RET_ERR(PM_ERR_MEMORY, -1));
+ STRDUP(newpkg->name, ptr, return -1);
newpkg->name_hash = _alpm_hash_sdbm(newpkg->name);
} else if(strcmp(key, "pkgbase") == 0) {
/* not used atm */
} else if(strcmp(key, "pkgver") == 0) {
- STRDUP(newpkg->version, ptr, RET_ERR(PM_ERR_MEMORY, -1));
+ STRDUP(newpkg->version, ptr, return -1);
} else if(strcmp(key, "pkgdesc") == 0) {
- STRDUP(newpkg->desc, ptr, RET_ERR(PM_ERR_MEMORY, -1));
+ STRDUP(newpkg->desc, ptr, return -1);
} else if(strcmp(key, "group") == 0) {
newpkg->groups = alpm_list_add(newpkg->groups, strdup(ptr));
} else if(strcmp(key, "url") == 0) {
- STRDUP(newpkg->url, ptr, RET_ERR(PM_ERR_MEMORY, -1));
+ STRDUP(newpkg->url, ptr, return -1);
} else if(strcmp(key, "license") == 0) {
newpkg->licenses = alpm_list_add(newpkg->licenses, strdup(ptr));
} else if(strcmp(key, "builddate") == 0) {
newpkg->builddate = _alpm_parsedate(ptr);
} else if(strcmp(key, "packager") == 0) {
- STRDUP(newpkg->packager, ptr, RET_ERR(PM_ERR_MEMORY, -1));
+ STRDUP(newpkg->packager, ptr, return -1);
} else if(strcmp(key, "arch") == 0) {
- STRDUP(newpkg->arch, ptr, RET_ERR(PM_ERR_MEMORY, -1));
+ STRDUP(newpkg->arch, ptr, return -1);
} else if(strcmp(key, "size") == 0) {
/* size in the raw package is uncompressed (installed) size */
newpkg->isize = atol(ptr);
} else if(strcmp(key, "depend") == 0) {
- pmdepend_t *dep = _alpm_splitdep(ptr);
+ alpm_depend_t *dep = _alpm_splitdep(ptr);
newpkg->depends = alpm_list_add(newpkg->depends, dep);
} else if(strcmp(key, "optdepend") == 0) {
newpkg->optdepends = alpm_list_add(newpkg->optdepends, strdup(ptr));
@@ -213,70 +200,148 @@ static int parse_descfile(struct archive *a, pmpkg_t *newpkg)
} else if(strcmp(key, "provides") == 0) {
newpkg->provides = alpm_list_add(newpkg->provides, strdup(ptr));
} else if(strcmp(key, "backup") == 0) {
- newpkg->backup = alpm_list_add(newpkg->backup, strdup(ptr));
+ alpm_backup_t *backup;
+ CALLOC(backup, 1, sizeof(alpm_backup_t), return -1);
+ STRDUP(backup->name, ptr, return -1);
+ newpkg->backup = alpm_list_add(newpkg->backup, backup);
} else if(strcmp(key, "force") == 0) {
/* deprecated, skip it */
} else if(strcmp(key, "makepkgopt") == 0) {
/* not used atm */
} else {
- _alpm_log(PM_LOG_DEBUG, "%s: unknown key '%s' in description file line %d\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "%s: unknown key '%s' in description file line %d\n",
newpkg->name ? newpkg->name : "error", key, linenum);
}
}
- line[0] = '\0';
}
+ if(ret != ARCHIVE_EOF) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "error parsing package descfile\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+static void files_merge(alpm_file_t a[], alpm_file_t b[], alpm_file_t c[],
+ size_t m, size_t n)
+{
+ size_t i = 0, j = 0, k = 0;
+ while(i < m && j < n) {
+ if(strcmp(a[i].name, b[j].name) < 0) {
+ c[k++] = a[i++];
+ } else {
+ c[k++] = b[j++];
+ }
+ }
+ while(i < m) {
+ c[k++] = a[i++];
+ }
+ while(j < n) {
+ c[k++] = b[j++];
+ }
+}
- return(0);
+static alpm_file_t *files_msort(alpm_file_t *files, size_t n)
+{
+ alpm_file_t *work;
+ size_t blocksize = 1;
+
+ CALLOC(work, n, sizeof(alpm_file_t), return NULL);
+
+ for(blocksize = 1; blocksize < n; blocksize *= 2) {
+ size_t i, max_extent = 0;
+ for(i = 0; i < n - blocksize; i += 2 * blocksize) {
+ /* this limits our actual merge to the length of the array, since we will
+ * not likely be a perfect power of two. */
+ size_t right_blocksize = blocksize;
+ if(i + blocksize * 2 > n) {
+ right_blocksize = n - i - blocksize;
+ }
+ files_merge(files + i, files + i + blocksize, work + i,
+ blocksize, right_blocksize);
+ max_extent = i + blocksize + right_blocksize;
+ }
+ /* ensure we only copy what we actually touched on this merge pass,
+ * no more, no less */
+ memcpy(files, work, max_extent * sizeof(alpm_file_t));
+ }
+ free(work);
+ return files;
}
/**
- * Load a package and create the corresponding pmpkg_t struct.
+ * Load a package and create the corresponding alpm_pkg_t struct.
+ * @param handle the context handle
* @param pkgfile path to the package file
* @param full whether to stop the load after metadata is read or continue
* through the full archive
- * @return An information filled pmpkg_t struct
+ * @return An information filled alpm_pkg_t struct
*/
-static pmpkg_t *pkg_load(const char *pkgfile, int full)
+alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle, const char *pkgfile,
+ int full, const char *md5sum, const char *base64_sig,
+ alpm_siglevel_t level)
{
- int ret = ARCHIVE_OK;
+ int ret;
int config = 0;
struct archive *archive;
struct archive_entry *entry;
- pmpkg_t *newpkg = NULL;
+ alpm_pkg_t *newpkg = NULL;
struct stat st;
-
- ALPM_LOG_FUNC;
+ size_t files_count = 0, files_size = 0;
+ alpm_file_t *files = NULL;
if(pkgfile == NULL || strlen(pkgfile) == 0) {
- RET_ERR(PM_ERR_WRONG_ARGS, NULL);
+ RET_ERR(handle, ALPM_ERR_WRONG_ARGS, NULL);
}
- if(stat(pkgfile, &st) != 0) {
- RET_ERR(PM_ERR_PKG_OPEN, NULL);
+ /* attempt to stat the package file, ensure it exists */
+ if(stat(pkgfile, &st) == 0) {
+ newpkg = _alpm_pkg_new();
+ if(newpkg == NULL) {
+ RET_ERR(handle, ALPM_ERR_MEMORY, NULL);
+ }
+ newpkg->filename = strdup(pkgfile);
+ newpkg->size = st.st_size;
+ } else {
+ /* couldn't stat the pkgfile, return an error */
+ RET_ERR(handle, ALPM_ERR_PKG_OPEN, NULL);
}
+ /* first steps- validate the package file */
+ _alpm_log(handle, ALPM_LOG_DEBUG, "md5sum: %s\n", md5sum);
+ if(md5sum) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "checking md5sum for %s\n", pkgfile);
+ if(_alpm_test_md5sum(pkgfile, md5sum) != 0) {
+ alpm_pkg_free(newpkg);
+ RET_ERR(handle, ALPM_ERR_PKG_INVALID, NULL);
+ }
+ }
+
+ _alpm_log(handle, ALPM_LOG_DEBUG, "base64_sig: %s\n", base64_sig);
+ if(level & ALPM_SIG_PACKAGE &&
+ _alpm_check_pgp_helper(handle, pkgfile, base64_sig,
+ level & ALPM_SIG_PACKAGE_OPTIONAL, level & ALPM_SIG_PACKAGE_MARGINAL_OK,
+ level & ALPM_SIG_PACKAGE_UNKNOWN_OK, ALPM_ERR_PKG_INVALID_SIG)) {
+ _alpm_pkg_free(newpkg);
+ return NULL;
+ }
+
+ /* next- try to create an archive object to read in the package */
if((archive = archive_read_new()) == NULL) {
- RET_ERR(PM_ERR_LIBARCHIVE, NULL);
+ alpm_pkg_free(newpkg);
+ RET_ERR(handle, ALPM_ERR_LIBARCHIVE, NULL);
}
archive_read_support_compression_all(archive);
archive_read_support_format_all(archive);
- if (archive_read_open_filename(archive, pkgfile,
+ if(archive_read_open_filename(archive, pkgfile,
ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
- RET_ERR(PM_ERR_PKG_OPEN, NULL);
- }
-
- newpkg = _alpm_pkg_new();
- if(newpkg == NULL) {
- archive_read_finish(archive);
- RET_ERR(PM_ERR_MEMORY, NULL);
+ alpm_pkg_free(newpkg);
+ RET_ERR(handle, ALPM_ERR_PKG_OPEN, NULL);
}
- newpkg->filename = strdup(pkgfile);
- newpkg->size = st.st_size;
-
- _alpm_log(PM_LOG_DEBUG, "starting package load for %s\n", pkgfile);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "starting package load for %s\n", pkgfile);
/* If full is false, only read through the archive until we find our needed
* metadata. If it is true, read through the entire archive, which serves
@@ -286,17 +351,17 @@ static pmpkg_t *pkg_load(const char *pkgfile, int full)
if(strcmp(entry_name, ".PKGINFO") == 0) {
/* parse the info file */
- if(parse_descfile(archive, newpkg) != 0) {
- _alpm_log(PM_LOG_ERROR, _("could not parse package description file in %s\n"),
+ if(parse_descfile(handle, archive, newpkg) != 0) {
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not parse package description file in %s\n"),
pkgfile);
goto pkg_invalid;
}
if(newpkg->name == NULL || strlen(newpkg->name) == 0) {
- _alpm_log(PM_LOG_ERROR, _("missing package name in %s\n"), pkgfile);
+ _alpm_log(handle, ALPM_LOG_ERROR, _("missing package name in %s\n"), pkgfile);
goto pkg_invalid;
}
if(newpkg->version == NULL || strlen(newpkg->version) == 0) {
- _alpm_log(PM_LOG_ERROR, _("missing package version in %s\n"), pkgfile);
+ _alpm_log(handle, ALPM_LOG_ERROR, _("missing package version in %s\n"), pkgfile);
goto pkg_invalid;
}
config = 1;
@@ -308,13 +373,33 @@ static pmpkg_t *pkg_load(const char *pkgfile, int full)
* already been handled (for future possibilities) */
} else if(full) {
/* Keep track of all files for filelist generation */
- newpkg->files = alpm_list_add(newpkg->files, strdup(entry_name));
+ if(files_count >= files_size) {
+ size_t old_size = files_size;
+ if(files_size == 0) {
+ files_size = 4;
+ } else {
+ files_size *= 2;
+ }
+ files = realloc(files, sizeof(alpm_file_t) * files_size);
+ if(!files) {
+ ALLOC_FAIL(sizeof(alpm_file_t) * files_size);
+ goto error;
+ }
+ /* ensure all new memory is zeroed out, in both the initial
+ * allocation and later reallocs */
+ memset(files + old_size, 0,
+ sizeof(alpm_file_t) * (files_size - old_size));
+ }
+ STRDUP(files[files_count].name, entry_name, goto error);
+ files[files_count].size = archive_entry_size(entry);
+ files[files_count].mode = archive_entry_mode(entry);
+ files_count++;
}
if(archive_read_data_skip(archive)) {
- _alpm_log(PM_LOG_ERROR, _("error while reading package %s: %s\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("error while reading package %s: %s\n"),
pkgfile, archive_error_string(archive));
- pm_errno = PM_ERR_LIBARCHIVE;
+ handle->pm_errno = ALPM_ERR_LIBARCHIVE;
goto error;
}
@@ -325,14 +410,14 @@ static pmpkg_t *pkg_load(const char *pkgfile, int full)
}
if(ret != ARCHIVE_EOF && ret != ARCHIVE_OK) { /* An error occured */
- _alpm_log(PM_LOG_ERROR, _("error while reading package %s: %s\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("error while reading package %s: %s\n"),
pkgfile, archive_error_string(archive));
- pm_errno = PM_ERR_LIBARCHIVE;
+ handle->pm_errno = ALPM_ERR_LIBARCHIVE;
goto error;
}
if(!config) {
- _alpm_log(PM_LOG_ERROR, _("missing package metadata in %s\n"), pkgfile);
+ _alpm_log(handle, ALPM_LOG_ERROR, _("missing package metadata in %s\n"), pkgfile);
goto pkg_invalid;
}
@@ -340,49 +425,46 @@ static pmpkg_t *pkg_load(const char *pkgfile, int full)
/* internal fields for package struct */
newpkg->origin = PKG_FROM_FILE;
- /* TODO eventually kill/move this? */
newpkg->origin_data.file = strdup(pkgfile);
newpkg->ops = get_file_pkg_ops();
+ newpkg->handle = handle;
if(full) {
+ /* attempt to hand back any memory we don't need */
+ files = realloc(files, sizeof(alpm_file_t) * files_count);
/* "checking for conflicts" requires a sorted list, ensure that here */
- _alpm_log(PM_LOG_DEBUG, "sorting package filelist for %s\n", pkgfile);
- newpkg->files = alpm_list_msort(newpkg->files, alpm_list_count(newpkg->files),
- _alpm_str_cmp);
- newpkg->infolevel = INFRQ_ALL;
+ _alpm_log(handle, ALPM_LOG_DEBUG, "sorting package filelist for %s\n", pkgfile);
+ newpkg->files.files = files_msort(files, files_count);
+ newpkg->files.count = files_count;
+ newpkg->infolevel = INFRQ_BASE | INFRQ_DESC | INFRQ_FILES | INFRQ_SCRIPTLET;
} else {
- /* get rid of any partial filelist we may have collected, it is invalid */
- FREELIST(newpkg->files);
- newpkg->infolevel = INFRQ_BASE | INFRQ_DESC;
+ newpkg->infolevel = INFRQ_BASE | INFRQ_DESC | INFRQ_SCRIPTLET;
}
- return(newpkg);
+ return newpkg;
pkg_invalid:
- pm_errno = PM_ERR_PKG_INVALID;
+ handle->pm_errno = ALPM_ERR_PKG_INVALID;
error:
_alpm_pkg_free(newpkg);
archive_read_finish(archive);
- return(NULL);
+ return NULL;
}
-int SYMEXPORT alpm_pkg_load(const char *filename, int full, pmpkg_t **pkg)
+int SYMEXPORT alpm_pkg_load(alpm_handle_t *handle, const char *filename, int full,
+ alpm_siglevel_t level, alpm_pkg_t **pkg)
{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(filename != NULL && strlen(filename) != 0,
- RET_ERR(PM_ERR_WRONG_ARGS, -1));
- ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
+ CHECK_HANDLE(handle, return -1);
+ ASSERT(pkg != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
- *pkg = pkg_load(filename, full);
+ *pkg = _alpm_pkg_load_internal(handle, filename, full, NULL, NULL, level);
if(*pkg == NULL) {
/* pm_errno is set by pkg_load */
- return(-1);
+ return -1;
}
- return(0);
+ return 0;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/be_sync.c b/lib/libalpm/be_sync.c
index c440cd6b..d4c71a8e 100644
--- a/lib/libalpm/be_sync.c
+++ b/lib/libalpm/be_sync.c
@@ -1,5 +1,5 @@
/*
- * be_sync.c
+ * be_sync.c : backend for sync databases
*
* Copyright (c) 2006-2011 Pacman Development Team <pacman-dev@archlinux.org>
* Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
@@ -21,7 +21,8 @@
#include "config.h"
#include <errno.h>
-#include <limits.h>
+#include <sys/stat.h>
+#include <unistd.h>
/* libarchive */
#include <archive.h>
@@ -38,32 +39,93 @@
#include "deps.h"
#include "dload.h"
+static char *get_sync_dir(alpm_handle_t *handle)
+{
+ const char *dbpath = alpm_option_get_dbpath(handle);
+ size_t len = strlen(dbpath) + 6;
+ char *syncpath;
+ struct stat buf;
+
+ MALLOC(syncpath, len, RET_ERR(handle, ALPM_ERR_MEMORY, NULL));
+ sprintf(syncpath, "%s%s", dbpath, "sync/");
+
+ if(stat(syncpath, &buf) != 0) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
+ syncpath);
+ if(_alpm_makepath(syncpath) != 0) {
+ free(syncpath);
+ RET_ERR(handle, ALPM_ERR_SYSTEM, NULL);
+ }
+ } else if(!S_ISDIR(buf.st_mode)) {
+ _alpm_log(handle, ALPM_LOG_WARNING, _("removing invalid file: %s\n"), syncpath);
+ if(unlink(syncpath) != 0 || _alpm_makepath(syncpath) != 0) {
+ free(syncpath);
+ RET_ERR(handle, ALPM_ERR_SYSTEM, NULL);
+ }
+ }
+
+ return syncpath;
+}
+
+static int sync_db_validate(alpm_db_t *db)
+{
+ alpm_siglevel_t level;
+
+ if(db->status & DB_STATUS_VALID) {
+ return 0;
+ }
+
+ /* this takes into account the default verification level if UNKNOWN
+ * was assigned to this db */
+ level = alpm_db_get_siglevel(db);
+
+ if(level & ALPM_SIG_DATABASE) {
+ const char *dbpath = _alpm_db_path(db);
+ if(!dbpath) {
+ /* pm_errno set in _alpm_db_path() */
+ return -1;
+ }
+
+ /* we can skip any validation if the database doesn't exist */
+ if(access(dbpath, R_OK) != 0 && errno == ENOENT) {
+ goto valid;
+ return 0;
+ }
+
+ if(_alpm_check_pgp_helper(db->handle, dbpath, NULL,
+ level & ALPM_SIG_DATABASE_OPTIONAL, level & ALPM_SIG_DATABASE_MARGINAL_OK,
+ level & ALPM_SIG_DATABASE_UNKNOWN_OK, ALPM_ERR_DB_INVALID_SIG)) {
+ return 1;
+ }
+ }
+
+valid:
+ db->status |= DB_STATUS_VALID;
+ return 0;
+}
+
/** Update a package database
*
* An update of the package database \a db will be attempted. Unless
* \a force is true, the update will only be performed if the remote
* database was modified since the last update.
*
- * A transaction is necessary for this operation, in order to obtain a
- * database lock. During this transaction the front-end will be informed
- * of the download progress of the database via the download callback.
+ * This operation requires a database lock, and will return an applicable error
+ * if the lock could not be obtained.
*
* Example:
* @code
* alpm_list_t *syncs = alpm_option_get_syncdbs();
- * if(alpm_trans_init(0, NULL, NULL, NULL) == 0) {
- * for(i = syncs; i; i = alpm_list_next(i)) {
- * pmdb_t *db = alpm_list_getdata(i);
- * result = alpm_db_update(0, db);
- * alpm_trans_release();
+ * for(i = syncs; i; i = alpm_list_next(i)) {
+ * alpm_db_t *db = alpm_list_getdata(i);
+ * result = alpm_db_update(0, db);
*
- * if(result < 0) {
- * printf("Unable to update database: %s\n", alpm_strerrorlast());
- * } else if(result == 1) {
- * printf("Database already up to date\n");
- * } else {
- * printf("Database updated\n");
- * }
+ * if(result < 0) {
+ * printf("Unable to update database: %s\n", alpm_strerrorlast());
+ * } else if(result == 1) {
+ * printf("Database already up to date\n");
+ * } else {
+ * printf("Database updated\n");
* }
* }
* @endcode
@@ -77,78 +139,175 @@
* @return 0 on success, -1 on error (pm_errno is set accordingly), 1 if up to
* to date
*/
-int SYMEXPORT alpm_db_update(int force, pmdb_t *db)
+int SYMEXPORT alpm_db_update(int force, alpm_db_t *db)
{
- char *dbfile, *syncpath;
- const char *dbpath;
- struct stat buf;
- size_t len;
- int ret;
+ char *syncpath;
+ alpm_list_t *i;
+ int ret = -1;
mode_t oldmask;
-
- ALPM_LOG_FUNC;
+ alpm_handle_t *handle;
+ alpm_siglevel_t level;
/* Sanity checks */
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
- ASSERT(db != NULL && db != handle->db_local, RET_ERR(PM_ERR_WRONG_ARGS, -1));
+ ASSERT(db != NULL, return -1);
+ handle = db->handle;
+ handle->pm_errno = 0;
+ ASSERT(db != handle->db_local, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
+ ASSERT(db->servers != NULL, RET_ERR(handle, ALPM_ERR_SERVER_NONE, -1));
+
+ syncpath = get_sync_dir(handle);
+ if(!syncpath) {
+ return -1;
+ }
- if(!alpm_list_find_ptr(handle->dbs_sync, db)) {
- RET_ERR(PM_ERR_DB_NOT_FOUND, -1);
+ /* make sure we have a sane umask */
+ oldmask = umask(0022);
+
+ level = alpm_db_get_siglevel(db);
+
+ /* attempt to grab a lock */
+ if(_alpm_handle_lock(handle)) {
+ RET_ERR(handle, ALPM_ERR_HANDLE_LOCK, -1);
}
- len = strlen(db->treename) + 4;
- MALLOC(dbfile, len, RET_ERR(PM_ERR_MEMORY, -1));
- sprintf(dbfile, "%s.db", db->treename);
+ for(i = db->servers; i; i = i->next) {
+ const char *server = i->data;
+ struct dload_payload *payload;
+ size_t len;
+ int sig_ret = 0;
- dbpath = alpm_option_get_dbpath();
- len = strlen(dbpath) + 6;
- MALLOC(syncpath, len, RET_ERR(PM_ERR_MEMORY, -1));
- sprintf(syncpath, "%s%s", dbpath, "sync/");
+ CALLOC(payload, 1, sizeof(*payload), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
- /* make sure we have a sane umask */
- oldmask = umask(0022);
+ /* set hard upper limit of 25MiB */
+ payload->max_size = 25 * 1024 * 1024;
- if(stat(syncpath, &buf) != 0) {
- _alpm_log(PM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
- syncpath);
- if(_alpm_makepath(syncpath) != 0) {
- free(dbfile);
- free(syncpath);
- RET_ERR(PM_ERR_SYSTEM, -1);
+ /* print server + filename into a buffer (leave space for .sig) */
+ len = strlen(server) + strlen(db->treename) + 9;
+ CALLOC(payload->fileurl, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+ snprintf(payload->fileurl, len, "%s/%s.db", server, db->treename);
+ payload->handle = handle;
+ payload->force = force;
+
+ ret = _alpm_download(payload, syncpath, NULL);
+
+ if(ret == 0 && (level & ALPM_SIG_DATABASE)) {
+ /* an existing sig file is no good at this point */
+ char *sigpath = _alpm_db_sig_path(db);
+ if(!sigpath) {
+ ret = -1;
+ break;
+ }
+ unlink(sigpath);
+ free(sigpath);
+
+ /* if we downloaded a DB, we want the .sig from the same server */
+ snprintf(payload->fileurl, len, "%s/%s.db.sig", server, db->treename);
+ payload->handle = handle;
+ payload->force = 1;
+ payload->errors_ok = (level & ALPM_SIG_DATABASE_OPTIONAL);
+
+ /* set hard upper limit of 16KiB */
+ payload->max_size = 16 * 1024;
+
+ sig_ret = _alpm_download(payload, syncpath, NULL);
+ /* errors_ok suppresses error messages, but not the return code */
+ sig_ret = payload->errors_ok ? 0 : sig_ret;
}
- } else if(!S_ISDIR(buf.st_mode)) {
- _alpm_log(PM_LOG_WARNING, _("removing invalid file: %s\n"), syncpath);
- if(unlink(syncpath) != 0 || _alpm_makepath(syncpath) != 0) {
- free(dbfile);
- free(syncpath);
- RET_ERR(PM_ERR_SYSTEM, -1);
+
+ _alpm_dload_payload_free(payload);
+ if(ret != -1 && sig_ret != -1) {
+ break;
}
}
- ret = _alpm_download_single_file(dbfile, db->servers, syncpath, force);
- free(dbfile);
- free(syncpath);
- umask(oldmask);
-
if(ret == 1) {
/* files match, do nothing */
- pm_errno = 0;
- return(1);
+ handle->pm_errno = 0;
+ goto cleanup;
} else if(ret == -1) {
/* pm_errno was set by the download code */
- _alpm_log(PM_LOG_DEBUG, "failed to sync db: %s\n", alpm_strerrorlast());
- return(-1);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "failed to sync db: %s\n",
+ alpm_strerror(handle->pm_errno));
+ goto cleanup;
}
/* Cache needs to be rebuilt */
_alpm_db_free_pkgcache(db);
- return(0);
+ db->status &= ~DB_STATUS_VALID;
+ if(sync_db_validate(db)) {
+ /* pm_errno should be set */
+ ret = -1;
+ }
+
+cleanup:
+
+ if(_alpm_handle_unlock(handle)) {
+ _alpm_log(handle, ALPM_LOG_WARNING, _("could not remove lock file %s\n"),
+ alpm_option_get_lockfile(handle));
+ }
+ free(syncpath);
+ umask(oldmask);
+ return ret;
}
/* Forward decl so I don't reorganize the whole file right now */
-static int sync_db_read(pmdb_t *db, struct archive *archive,
- struct archive_entry *entry, pmpkg_t *likely_pkg);
+static int sync_db_read(alpm_db_t *db, struct archive *archive,
+ struct archive_entry *entry, alpm_pkg_t **likely_pkg);
+
+static alpm_pkg_t *load_pkg_for_entry(alpm_db_t *db, const char *entryname,
+ const char **entry_filename, alpm_pkg_t *likely_pkg)
+{
+ char *pkgname = NULL, *pkgver = NULL;
+ unsigned long pkgname_hash;
+ alpm_pkg_t *pkg;
+
+ /* get package and db file names */
+ if(entry_filename) {
+ char *fname = strrchr(entryname, '/');
+ if(fname) {
+ *entry_filename = fname + 1;
+ } else {
+ *entry_filename = NULL;
+ }
+ }
+ if(_alpm_splitname(entryname, &pkgname, &pkgver, &pkgname_hash) != 0) {
+ _alpm_log(db->handle, ALPM_LOG_ERROR,
+ _("invalid name for database entry '%s'\n"), entryname);
+ return NULL;
+ }
+
+ if(likely_pkg && strcmp(likely_pkg->name, pkgname) == 0) {
+ pkg = likely_pkg;
+ } else {
+ pkg = _alpm_pkghash_find(db->pkgcache, pkgname);
+ }
+ if(pkg == NULL) {
+ pkg = _alpm_pkg_new();
+ if(pkg == NULL) {
+ RET_ERR(db->handle, ALPM_ERR_MEMORY, NULL);
+ }
+
+ pkg->name = pkgname;
+ pkg->version = pkgver;
+ pkg->name_hash = pkgname_hash;
+
+ pkg->origin = PKG_FROM_SYNCDB;
+ pkg->origin_data.db = db;
+ pkg->ops = &default_pkg_ops;
+ pkg->handle = db->handle;
+
+ /* add to the collection */
+ _alpm_log(db->handle, ALPM_LOG_FUNCTION, "adding '%s' to package cache for db '%s'\n",
+ pkg->name, db->treename);
+ db->pkgcache = _alpm_pkghash_add(db->pkgcache, pkg);
+ } else {
+ free(pkgname);
+ free(pkgver);
+ }
+
+ return pkg;
+}
/*
* This is the data table used to generate the estimating function below.
@@ -206,10 +365,10 @@ static size_t estimate_package_count(struct stat *st, struct archive *archive)
/* assume it is at least somewhat compressed */
per_package = 200;
}
- return((size_t)(st->st_size / per_package) + 1);
+ return (size_t)((st->st_size / per_package) + 1);
}
-static int sync_db_populate(pmdb_t *db)
+static int sync_db_populate(alpm_db_t *db)
{
const char *dbpath;
size_t est_count;
@@ -217,14 +376,10 @@ static int sync_db_populate(pmdb_t *db)
struct stat buf;
struct archive *archive;
struct archive_entry *entry;
- pmpkg_t *pkg = NULL;
-
- ALPM_LOG_FUNC;
-
- ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
+ alpm_pkg_t *pkg = NULL;
if((archive = archive_read_new()) == NULL) {
- RET_ERR(PM_ERR_LIBARCHIVE, -1);
+ RET_ERR(db->handle, ALPM_ERR_LIBARCHIVE, -1);
}
archive_read_support_compression_all(archive);
@@ -236,24 +391,24 @@ static int sync_db_populate(pmdb_t *db)
return -1;
}
- _alpm_log(PM_LOG_DEBUG, "opening database archive %s\n", dbpath);
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "opening database archive %s\n", dbpath);
if(archive_read_open_filename(archive, dbpath,
ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
- _alpm_log(PM_LOG_ERROR, _("could not open file %s: %s\n"), dbpath,
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"), dbpath,
archive_error_string(archive));
archive_read_finish(archive);
- RET_ERR(PM_ERR_DB_OPEN, -1);
+ RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
}
if(stat(dbpath, &buf) != 0) {
- RET_ERR(PM_ERR_DB_OPEN, -1);
+ RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
}
est_count = estimate_package_count(&buf, archive);
/* initialize hash at 66% full */
db->pkgcache = _alpm_pkghash_create(est_count * 3 / 2);
if(db->pkgcache == NULL) {
- RET_ERR(PM_ERR_MEMORY, -1);
+ RET_ERR(db->handle, ALPM_ERR_MEMORY, -1);
}
while(archive_read_next_header(archive, &entry) == ARCHIVE_OK) {
@@ -262,139 +417,96 @@ static int sync_db_populate(pmdb_t *db)
st = archive_entry_stat(entry);
if(S_ISDIR(st->st_mode)) {
- const char *name;
-
- pkg = _alpm_pkg_new();
- if(pkg == NULL) {
- archive_read_finish(archive);
- RET_ERR(PM_ERR_MEMORY, -1);
- }
-
- name = archive_entry_pathname(entry);
-
- if(_alpm_splitname(name, pkg) != 0) {
- _alpm_log(PM_LOG_ERROR, _("invalid name for database entry '%s'\n"),
- name);
- _alpm_pkg_free(pkg);
- continue;
- }
-
- /* duplicated database entries are not allowed */
- if(_alpm_pkghash_find(db->pkgcache, pkg->name)) {
- _alpm_log(PM_LOG_ERROR, _("duplicated database entry '%s'\n"), pkg->name);
- _alpm_pkg_free(pkg);
- continue;
- }
-
- pkg->origin = PKG_FROM_SYNCDB;
- pkg->ops = &default_pkg_ops;
- pkg->origin_data.db = db;
-
- /* add to the collection */
- _alpm_log(PM_LOG_FUNCTION, "adding '%s' to package cache for db '%s'\n",
- pkg->name, db->treename);
- db->pkgcache = _alpm_pkghash_add(db->pkgcache, pkg);
- count++;
+ continue;
} else {
/* we have desc, depends or deltas - parse it */
- sync_db_read(db, archive, entry, pkg);
+ if(sync_db_read(db, archive, entry, &pkg) != 0) {
+ _alpm_log(db->handle, ALPM_LOG_ERROR,
+ _("could not parse package description file '%s' from db '%s'\n"),
+ archive_entry_pathname(entry), db->treename);
+ continue;
+ }
}
}
+ count = alpm_list_count(db->pkgcache->list);
+
if(count > 0) {
db->pkgcache->list = alpm_list_msort(db->pkgcache->list, (size_t)count, _alpm_pkg_cmp);
}
archive_read_finish(archive);
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "added %d packages to package cache for db '%s'\n",
+ count, db->treename);
- return(count);
+ return count;
}
-#define READ_NEXT(s) do { \
+#define READ_NEXT() do { \
if(_alpm_archive_fgets(archive, &buf) != ARCHIVE_OK) goto error; \
- s = _alpm_strtrim(buf.line); \
+ line = buf.line; \
+ _alpm_strip_newline(line); \
} while(0)
#define READ_AND_STORE(f) do { \
- READ_NEXT(line); \
+ READ_NEXT(); \
STRDUP(f, line, goto error); \
} while(0)
#define READ_AND_STORE_ALL(f) do { \
char *linedup; \
- READ_NEXT(line); \
- if(strlen(line) == 0) break; \
- STRDUP(linedup, line, goto error); \
+ if(_alpm_archive_fgets(archive, &buf) != ARCHIVE_OK) goto error; \
+ if(_alpm_strip_newline(buf.line) == 0) break; \
+ STRDUP(linedup, buf.line, goto error); \
f = alpm_list_add(f, linedup); \
} while(1) /* note the while(1) and not (0) */
-static int sync_db_read(pmdb_t *db, struct archive *archive,
- struct archive_entry *entry, pmpkg_t *likely_pkg)
+static int sync_db_read(alpm_db_t *db, struct archive *archive,
+ struct archive_entry *entry, alpm_pkg_t **likely_pkg)
{
- const char *entryname = NULL, *filename;
- char *pkgname, *p, *q;
- pmpkg_t *pkg;
+ const char *entryname, *filename;
+ alpm_pkg_t *pkg;
struct archive_read_buffer buf;
- ALPM_LOG_FUNC;
-
- if(db == NULL) {
- RET_ERR(PM_ERR_DB_NULL, -1);
- }
-
- if(entry != NULL) {
- entryname = archive_entry_pathname(entry);
- }
+ entryname = archive_entry_pathname(entry);
if(entryname == NULL) {
- _alpm_log(PM_LOG_DEBUG, "invalid archive entry provided to _alpm_sync_db_read, skipping\n");
- return(-1);
+ _alpm_log(db->handle, ALPM_LOG_DEBUG,
+ "invalid archive entry provided to _alpm_sync_db_read, skipping\n");
+ return -1;
}
- _alpm_log(PM_LOG_FUNCTION, "loading package data from archive entry %s\n",
+ _alpm_log(db->handle, ALPM_LOG_FUNCTION, "loading package data from archive entry %s\n",
entryname);
memset(&buf, 0, sizeof(buf));
/* 512K for a line length seems reasonable */
buf.max_line_size = 512 * 1024;
- /* get package and db file names */
- STRDUP(pkgname, entryname, RET_ERR(PM_ERR_MEMORY, -1));
- p = pkgname + strlen(pkgname);
- for(q = --p; *q && *q != '/'; q--);
- filename = q + 1;
- for(p = --q; *p && *p != '-'; p--);
- for(q = --p; *q && *q != '-'; q--);
- *q = '\0';
-
- /* package is already in db due to parsing of directory name */
- if(likely_pkg && strcmp(likely_pkg->name, pkgname) == 0) {
- pkg = likely_pkg;
- } else {
- if(db->pkgcache == NULL) {
- RET_ERR(PM_ERR_MEMORY, -1);
- }
- pkg = _alpm_pkghash_find(db->pkgcache, pkgname);
- }
+ pkg = load_pkg_for_entry(db, entryname, &filename, *likely_pkg);
+
if(pkg == NULL) {
- _alpm_log(PM_LOG_DEBUG, "package %s not found in %s sync database",
- pkgname, db->treename);
- return(-1);
+ _alpm_log(db->handle, ALPM_LOG_DEBUG,
+ "entry %s could not be loaded into %s sync database",
+ entryname, db->treename);
+ return -1;
}
if(strcmp(filename, "desc") == 0 || strcmp(filename, "depends") == 0
|| strcmp(filename, "deltas") == 0) {
- while(_alpm_archive_fgets(archive, &buf) == ARCHIVE_OK) {
- char *line = _alpm_strtrim(buf.line);
+ int ret;
+ while((ret = _alpm_archive_fgets(archive, &buf)) == ARCHIVE_OK) {
+ char *line = buf.line;
+ _alpm_strip_newline(line);
if(strcmp(line, "%NAME%") == 0) {
- READ_NEXT(line);
+ READ_NEXT();
if(strcmp(line, pkg->name) != 0) {
- _alpm_log(PM_LOG_ERROR, _("%s database is inconsistent: name "
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("%s database is inconsistent: name "
"mismatch on package %s\n"), db->treename, pkg->name);
}
} else if(strcmp(line, "%VERSION%") == 0) {
- READ_NEXT(line);
+ READ_NEXT();
if(strcmp(line, pkg->version) != 0) {
- _alpm_log(PM_LOG_ERROR, _("%s database is inconsistent: version "
+ _alpm_log(db->handle, ALPM_LOG_ERROR, _("%s database is inconsistent: version "
"mismatch on package %s\n"), db->treename, pkg->name);
}
} else if(strcmp(line, "%FILENAME%") == 0) {
@@ -410,7 +522,7 @@ static int sync_db_read(pmdb_t *db, struct archive *archive,
} else if(strcmp(line, "%ARCH%") == 0) {
READ_AND_STORE(pkg->arch);
} else if(strcmp(line, "%BUILDDATE%") == 0) {
- READ_NEXT(line);
+ READ_NEXT();
pkg->builddate = _alpm_parsedate(line);
} else if(strcmp(line, "%PACKAGER%") == 0) {
READ_AND_STORE(pkg->packager);
@@ -419,29 +531,28 @@ static int sync_db_read(pmdb_t *db, struct archive *archive,
* pkginfo_t struct. This can be done b/c CSIZE is currently only used
* in sync databases, and SIZE is only used in local databases.
*/
- READ_NEXT(line);
+ READ_NEXT();
pkg->size = atol(line);
/* also store this value to isize if isize is unset */
if(pkg->isize == 0) {
pkg->isize = pkg->size;
}
} else if(strcmp(line, "%ISIZE%") == 0) {
- READ_NEXT(line);
+ READ_NEXT();
pkg->isize = atol(line);
} else if(strcmp(line, "%MD5SUM%") == 0) {
READ_AND_STORE(pkg->md5sum);
} else if(strcmp(line, "%SHA256SUM%") == 0) {
/* we don't do anything with this value right now */
- READ_NEXT(line);
+ READ_NEXT();
} else if(strcmp(line, "%PGPSIG%") == 0) {
- /* we don't do anything with this value right now */
- READ_NEXT(line);
+ READ_AND_STORE(pkg->base64_sig);
} else if(strcmp(line, "%REPLACES%") == 0) {
READ_AND_STORE_ALL(pkg->replaces);
} else if(strcmp(line, "%DEPENDS%") == 0) {
/* Different than the rest because of the _alpm_splitdep call. */
while(1) {
- READ_NEXT(line);
+ READ_NEXT();
if(strlen(line) == 0) break;
pkg->depends = alpm_list_add(pkg->depends, _alpm_splitdep(line));
}
@@ -454,62 +565,61 @@ static int sync_db_read(pmdb_t *db, struct archive *archive,
} else if(strcmp(line, "%DELTAS%") == 0) {
/* Different than the rest because of the _alpm_delta_parse call. */
while(1) {
- READ_NEXT(line);
+ READ_NEXT();
if(strlen(line) == 0) break;
pkg->deltas = alpm_list_add(pkg->deltas, _alpm_delta_parse(line));
}
}
}
+ if(ret != ARCHIVE_EOF) {
+ goto error;
+ }
+ *likely_pkg = pkg;
} else if(strcmp(filename, "files") == 0) {
/* currently do nothing with this file */
} else {
/* unknown database file */
- _alpm_log(PM_LOG_DEBUG, "unknown database file: %s\n", filename);
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "unknown database file: %s\n", filename);
}
-error:
- FREE(pkgname);
- /* TODO: return 0 always? */
- return(0);
-}
+ return 0;
-static int sync_db_version(pmdb_t *db)
-{
- return(2);
+error:
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "error parsing database file: %s\n", filename);
+ return -1;
}
struct db_operations sync_db_ops = {
+ .validate = sync_db_validate,
.populate = sync_db_populate,
.unregister = _alpm_db_unregister,
- .version = sync_db_version,
};
-pmdb_t *_alpm_db_register_sync(const char *treename)
+alpm_db_t *_alpm_db_register_sync(alpm_handle_t *handle, const char *treename,
+ alpm_siglevel_t level)
{
- pmdb_t *db;
- alpm_list_t *i;
+ alpm_db_t *db;
- ALPM_LOG_FUNC;
+ _alpm_log(handle, ALPM_LOG_DEBUG, "registering sync database '%s'\n", treename);
- 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;
- }
+#ifndef HAVE_LIBGPGME
+ if(level != 0 && level != ALPM_SIG_USE_DEFAULT) {
+ RET_ERR(handle, ALPM_ERR_WRONG_ARGS, NULL);
}
-
- _alpm_log(PM_LOG_DEBUG, "registering sync database '%s'\n", treename);
+#endif
db = _alpm_db_new(treename, 0);
if(db == NULL) {
- RET_ERR(PM_ERR_DB_CREATE, NULL);
+ RET_ERR(handle, ALPM_ERR_DB_CREATE, NULL);
}
db->ops = &sync_db_ops;
+ db->handle = handle;
+ db->siglevel = level;
+
+ sync_db_validate(db);
handle->dbs_sync = alpm_list_add(handle->dbs_sync, db);
- return(db);
+ return db;
}
-
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/conflict.c b/lib/libalpm/conflict.c
index db10d329..538c4c73 100644
--- a/lib/libalpm/conflict.c
+++ b/lib/libalpm/conflict.c
@@ -34,29 +34,28 @@
/* libalpm */
#include "conflict.h"
#include "alpm_list.h"
+#include "alpm.h"
#include "handle.h"
#include "trans.h"
#include "util.h"
#include "log.h"
#include "deps.h"
-pmconflict_t *_alpm_conflict_new(const char *package1, const char *package2,
+static alpm_conflict_t *conflict_new(const char *package1, const char *package2,
const char *reason)
{
- pmconflict_t *conflict;
+ alpm_conflict_t *conflict;
- ALPM_LOG_FUNC;
+ MALLOC(conflict, sizeof(alpm_conflict_t), return NULL);
- MALLOC(conflict, sizeof(pmconflict_t), RET_ERR(PM_ERR_MEMORY, NULL));
+ STRDUP(conflict->package1, package1, return NULL);
+ STRDUP(conflict->package2, package2, return NULL);
+ STRDUP(conflict->reason, reason, return NULL);
- STRDUP(conflict->package1, package1, RET_ERR(PM_ERR_MEMORY, NULL));
- STRDUP(conflict->package2, package2, RET_ERR(PM_ERR_MEMORY, NULL));
- STRDUP(conflict->reason, reason, RET_ERR(PM_ERR_MEMORY, NULL));
-
- return(conflict);
+ return conflict;
}
-void _alpm_conflict_free(pmconflict_t *conflict)
+void _alpm_conflict_free(alpm_conflict_t *conflict)
{
FREE(conflict->package2);
FREE(conflict->package1);
@@ -64,55 +63,59 @@ void _alpm_conflict_free(pmconflict_t *conflict)
FREE(conflict);
}
-pmconflict_t *_alpm_conflict_dup(const pmconflict_t *conflict)
+alpm_conflict_t *_alpm_conflict_dup(const alpm_conflict_t *conflict)
{
- pmconflict_t *newconflict;
- CALLOC(newconflict, 1, sizeof(pmconflict_t), RET_ERR(PM_ERR_MEMORY, NULL));
+ alpm_conflict_t *newconflict;
+ CALLOC(newconflict, 1, sizeof(alpm_conflict_t), return NULL);
- STRDUP(newconflict->package1, conflict->package1, RET_ERR(PM_ERR_MEMORY, NULL));
- STRDUP(newconflict->package2, conflict->package2, RET_ERR(PM_ERR_MEMORY, NULL));
- STRDUP(newconflict->reason, conflict->reason, RET_ERR(PM_ERR_MEMORY, NULL));
+ STRDUP(newconflict->package1, conflict->package1, return NULL);
+ STRDUP(newconflict->package2, conflict->package2, return NULL);
+ STRDUP(newconflict->reason, conflict->reason, return NULL);
- return(newconflict);
+ return newconflict;
}
-static int conflict_isin(pmconflict_t *needle, alpm_list_t *haystack)
+static int conflict_isin(alpm_conflict_t *needle, alpm_list_t *haystack)
{
alpm_list_t *i;
const char *npkg1 = needle->package1;
const char *npkg2 = needle->package2;
- ALPM_LOG_FUNC;
-
for(i = haystack; i; i = i->next) {
- pmconflict_t *conflict = i->data;
+ alpm_conflict_t *conflict = i->data;
const char *cpkg1 = conflict->package1;
const char *cpkg2 = conflict->package2;
if((strcmp(cpkg1, npkg1) == 0 && strcmp(cpkg2, npkg2) == 0)
|| (strcmp(cpkg1, npkg2) == 0 && strcmp(cpkg2, npkg1) == 0)) {
- return(1);
+ return 1;
}
}
- return(0);
+ return 0;
}
-/** Adds the pkg1/pkg2 conflict to the baddeps list
- * @param *baddeps list to add conflict to
+/** Adds the pkg1/pkg2 conflict to the baddeps list.
+ * @param handle the context handle
+ * @param baddeps list to add conflict to
* @param pkg1 first package
* @param pkg2 package causing conflict
+ * @param reason reason for this conflict
*/
-static void add_conflict(alpm_list_t **baddeps, const char *pkg1,
- const char *pkg2, const char *reason)
+static int add_conflict(alpm_handle_t *handle, alpm_list_t **baddeps,
+ const char *pkg1, const char *pkg2, const char *reason)
{
- pmconflict_t *conflict = _alpm_conflict_new(pkg1, pkg2, reason);
- _alpm_log(PM_LOG_DEBUG, "package %s conflicts with %s (by %s)\n",
+ alpm_conflict_t *conflict = conflict_new(pkg1, pkg2, reason);
+ if(!conflict) {
+ return -1;
+ }
+ _alpm_log(handle, ALPM_LOG_DEBUG, "package %s conflicts with %s (by %s)\n",
pkg1, pkg2, reason);
- if(conflict && !conflict_isin(conflict, *baddeps)) {
+ if(!conflict_isin(conflict, *baddeps)) {
*baddeps = alpm_list_add(*baddeps, conflict);
} else {
_alpm_conflict_free(conflict);
}
+ return 0;
}
/** Check if packages from list1 conflict with packages from list2.
@@ -121,28 +124,32 @@ static void add_conflict(alpm_list_t **baddeps, const char *pkg1,
* If a conflict (pkg1, pkg2) is found, it is added to the baddeps list
* in this order if order >= 0, or reverse order (pkg2,pkg1) otherwise.
*
+ * @param handle the context handle
* @param list1 first list of packages
* @param list2 second list of packages
- * @param *baddeps list to store conflicts
+ * @param baddeps list to store conflicts
* @param order if >= 0 the conflict order is preserved, if < 0 it's reversed
*/
-static void check_conflict(alpm_list_t *list1, alpm_list_t *list2,
+static void check_conflict(alpm_handle_t *handle,
+ alpm_list_t *list1, alpm_list_t *list2,
alpm_list_t **baddeps, int order) {
- alpm_list_t *i, *j, *k;
+ alpm_list_t *i;
if(!baddeps) {
return;
}
for(i = list1; i; i = i->next) {
- pmpkg_t *pkg1 = i->data;
+ alpm_pkg_t *pkg1 = i->data;
const char *pkg1name = alpm_pkg_get_name(pkg1);
+ alpm_list_t *j;
for(j = alpm_pkg_get_conflicts(pkg1); j; j = j->next) {
const char *conflict = j->data;
- pmdepend_t *parsed_conflict = _alpm_splitdep(conflict);
+ alpm_list_t *k;
+ alpm_depend_t *parsed_conflict = _alpm_splitdep(conflict);
for(k = list2; k; k = k->next) {
- pmpkg_t *pkg2 = k->data;
+ alpm_pkg_t *pkg2 = k->data;
const char *pkg2name = alpm_pkg_get_name(pkg2);
if(strcmp(pkg1name, pkg2name) == 0) {
@@ -152,9 +159,9 @@ static void check_conflict(alpm_list_t *list1, alpm_list_t *list2,
if(_alpm_depcmp(pkg2, parsed_conflict)) {
if(order >= 0) {
- add_conflict(baddeps, pkg1name, pkg2name, conflict);
+ add_conflict(handle, baddeps, pkg1name, pkg2name, conflict);
} else {
- add_conflict(baddeps, pkg2name, pkg1name, conflict);
+ add_conflict(handle, baddeps, pkg2name, pkg1name, conflict);
}
}
}
@@ -164,189 +171,183 @@ static void check_conflict(alpm_list_t *list1, alpm_list_t *list2,
}
/* Check for inter-conflicts */
-alpm_list_t *_alpm_innerconflicts(alpm_list_t *packages)
+alpm_list_t *_alpm_innerconflicts(alpm_handle_t *handle, alpm_list_t *packages)
{
alpm_list_t *baddeps = NULL;
- ALPM_LOG_FUNC;
-
- _alpm_log(PM_LOG_DEBUG, "check targets vs targets\n");
- check_conflict(packages, packages, &baddeps, 0);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "check targets vs targets\n");
+ check_conflict(handle, packages, packages, &baddeps, 0);
- return(baddeps);
+ return baddeps;
}
/* Check for target vs (db - target) conflicts
* In case of conflict the package1 field of pmdepconflict_t contains
* the target package, package2 field contains the local package
*/
-alpm_list_t *_alpm_outerconflicts(pmdb_t *db, alpm_list_t *packages)
+alpm_list_t *_alpm_outerconflicts(alpm_db_t *db, alpm_list_t *packages)
{
alpm_list_t *baddeps = NULL;
- ALPM_LOG_FUNC;
-
if(db == NULL) {
- return(NULL);
+ return NULL;
}
alpm_list_t *dblist = alpm_list_diff(_alpm_db_get_pkgcache(db),
packages, _alpm_pkg_cmp);
/* two checks to be done here for conflicts */
- _alpm_log(PM_LOG_DEBUG, "check targets vs db\n");
- check_conflict(packages, dblist, &baddeps, 1);
- _alpm_log(PM_LOG_DEBUG, "check db vs targets\n");
- check_conflict(dblist, packages, &baddeps, -1);
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "check targets vs db\n");
+ check_conflict(db->handle, packages, dblist, &baddeps, 1);
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "check db vs targets\n");
+ check_conflict(db->handle, dblist, packages, &baddeps, -1);
alpm_list_free(dblist);
- return(baddeps);
+ return baddeps;
}
/** Check the package conflicts in a database
*
+ * @param handle the context handle
* @param pkglist the list of packages to check
- * @return an alpm_list_t of pmconflict_t
+ * @return an alpm_list_t of alpm_conflict_t
*/
-alpm_list_t SYMEXPORT *alpm_checkconflicts(alpm_list_t *pkglist) {
- return(_alpm_innerconflicts(pkglist));
-}
-
-/* Returns a alpm_list_t* of file conflicts.
- * Hooray for set-intersects!
- * Pre-condition: both lists are sorted!
- */
-static alpm_list_t *chk_fileconflicts(alpm_list_t *filesA, alpm_list_t *filesB)
+alpm_list_t SYMEXPORT *alpm_checkconflicts(alpm_handle_t *handle,
+ alpm_list_t *pkglist)
{
- alpm_list_t *ret = NULL;
- alpm_list_t *pA = filesA, *pB = filesB;
-
- while(pA && pB) {
- const char *strA = pA->data;
- const char *strB = pB->data;
- /* skip directories, we don't care about dir conflicts */
- if(strA[strlen(strA)-1] == '/') {
- pA = pA->next;
- } else if(strB[strlen(strB)-1] == '/') {
- pB = pB->next;
- } else {
- int cmp = strcmp(strA, strB);
- if(cmp < 0) {
- /* item only in filesA, ignore it */
- pA = pA->next;
- } else if(cmp > 0) {
- /* item only in filesB, ignore it */
- pB = pB->next;
- } else {
- /* item in both, record it */
- ret = alpm_list_add(ret, strdup(strA));
- pA = pA->next;
- pB = pB->next;
- }
- }
- }
-
- return(ret);
+ CHECK_HANDLE(handle, return NULL);
+ return _alpm_innerconflicts(handle, pkglist);
}
-/* Returns a alpm_list_t* of files that are in filesA but *NOT* in filesB
- * This is an 'A minus B' set operation
- * Pre-condition: both lists are sorted!
+static const int DIFFERENCE = 0;
+static const int INTERSECT = 1;
+/* Returns a set operation on the provided two lists of files.
+ * Pre-condition: both lists are sorted!
+ * When done, free the list but NOT the contained data.
+ *
+ * Operations:
+ * DIFFERENCE - a difference operation is performed. filesA - filesB.
+ * INTERSECT - an intersection operation is performed. filesA & filesB.
*/
-static alpm_list_t *chk_filedifference(alpm_list_t *filesA, alpm_list_t *filesB)
+static alpm_list_t *filelist_operation(alpm_filelist_t *filesA,
+ alpm_filelist_t *filesB, int operation)
{
alpm_list_t *ret = NULL;
- alpm_list_t *pA = filesA, *pB = filesB;
-
- /* if both filesA and filesB have entries, do this loop */
- while(pA && pB) {
- const char *strA = pA->data;
- const char *strB = pB->data;
- /* skip directories, we don't care about dir conflicts */
+ size_t ctrA = 0, ctrB = 0;
+
+ while(ctrA < filesA->count && ctrB < filesB->count) {
+ alpm_file_t *fileA = filesA->files + ctrA;
+ alpm_file_t *fileB = filesB->files + ctrB;
+ const char *strA = fileA->name;
+ const char *strB = fileB->name;
+ /* skip directories, we don't care about them */
if(strA[strlen(strA)-1] == '/') {
- pA = pA->next;
+ ctrA++;
} else if(strB[strlen(strB)-1] == '/') {
- pB = pB->next;
+ ctrB++;
} else {
int cmp = strcmp(strA, strB);
if(cmp < 0) {
- /* item only in filesA, record it */
- ret = alpm_list_add(ret, strdup(strA));
- pA = pA->next;
+ if(operation == DIFFERENCE) {
+ /* item only in filesA, qualifies as a difference */
+ ret = alpm_list_add(ret, fileA);
+ }
+ ctrA++;
} else if(cmp > 0) {
- /* item only in fileB, but this means nothing */
- pB = pB->next;
+ ctrB++;
} else {
- /* item in both, ignore it */
- pA = pA->next;
- pB = pB->next;
+ if(operation == INTERSECT) {
+ /* item in both, qualifies as an intersect */
+ ret = alpm_list_add(ret, fileA);
+ }
+ ctrA++;
+ ctrB++;
}
}
}
- /* ensure we have completely emptied pA */
- while(pA) {
- const char *strA = pA->data;
+
+ /* if doing a difference, ensure we have completely emptied pA */
+ while(operation == DIFFERENCE && ctrA < filesA->count) {
+ alpm_file_t *fileA = filesA->files + ctrA;
+ const char *strA = fileA->name;
/* skip directories */
if(strA[strlen(strA)-1] != '/') {
- ret = alpm_list_add(ret, strdup(strA));
+ ret = alpm_list_add(ret, fileA);
}
- pA = pA->next;
+ ctrA++;
}
- return(ret);
+ return ret;
}
-/* Adds pmfileconflict_t to a conflicts list. Pass the conflicts list, type
- * (either PM_FILECONFLICT_TARGET or PM_FILECONFLICT_FILESYSTEM), a file
+/* Adds alpm_fileconflict_t to a conflicts list. Pass the conflicts list, type
+ * (either ALPM_FILECONFLICT_TARGET or ALPM_FILECONFLICT_FILESYSTEM), a file
* string, and either two package names or one package name and NULL. This is
* a wrapper for former functionality that was done inline.
*/
-static alpm_list_t *add_fileconflict(alpm_list_t *conflicts,
- pmfileconflicttype_t type, const char *filestr,
- const char *name1, const char *name2)
+static alpm_list_t *add_fileconflict(alpm_handle_t *handle,
+ alpm_list_t *conflicts, alpm_fileconflicttype_t type, const char *filestr,
+ const char *name1, const char *name2)
{
- pmfileconflict_t *conflict;
- MALLOC(conflict, sizeof(pmfileconflict_t), RET_ERR(PM_ERR_MEMORY, NULL));
+ alpm_fileconflict_t *conflict;
+ MALLOC(conflict, sizeof(alpm_fileconflict_t), goto error);
conflict->type = type;
- STRDUP(conflict->target, name1, RET_ERR(PM_ERR_MEMORY, NULL));
- STRDUP(conflict->file, filestr, RET_ERR(PM_ERR_MEMORY, NULL));
+ STRDUP(conflict->target, name1, goto error);
+ STRDUP(conflict->file, filestr, goto error);
if(name2) {
- STRDUP(conflict->ctarget, name2, RET_ERR(PM_ERR_MEMORY, NULL));
+ STRDUP(conflict->ctarget, name2, goto error);
} else {
- conflict->ctarget = "";
+ STRDUP(conflict->ctarget, "", goto error);
}
conflicts = alpm_list_add(conflicts, conflict);
- _alpm_log(PM_LOG_DEBUG, "found file conflict %s, packages %s and %s\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "found file conflict %s, packages %s and %s\n",
filestr, name1, name2 ? name2 : "(filesystem)");
- return(conflicts);
+ return conflicts;
+
+error:
+ RET_ERR(handle, ALPM_ERR_MEMORY, conflicts);
}
-void _alpm_fileconflict_free(pmfileconflict_t *conflict)
+void _alpm_fileconflict_free(alpm_fileconflict_t *conflict)
{
- if(strlen(conflict->ctarget) > 0) {
- FREE(conflict->ctarget);
- }
- FREE(conflict->file);;
+ FREE(conflict->ctarget);
+ FREE(conflict->file);
FREE(conflict->target);
FREE(conflict);
}
-static int dir_belongsto_pkg(const char *dirpath, pmpkg_t *pkg)
+const alpm_file_t *_alpm_filelist_contains(alpm_filelist_t *filelist,
+ const char *name)
+{
+ size_t i;
+ const alpm_file_t *file = filelist->files;
+ for(i = 0; i < filelist->count; i++) {
+ if(strcmp(file->name, name) == 0) {
+ return file;
+ }
+ file++;
+ }
+ return NULL;
+}
+
+static int dir_belongsto_pkg(const char *root, const char *dirpath,
+ alpm_pkg_t *pkg)
{
- struct dirent *ent = NULL;
struct stat sbuf;
char path[PATH_MAX];
char abspath[PATH_MAX];
+ struct dirent *ent = NULL;
DIR *dir;
- snprintf(abspath, PATH_MAX, "%s%s", handle->root, dirpath);
+ snprintf(abspath, PATH_MAX, "%s%s", root, dirpath);
dir = opendir(abspath);
if(dir == NULL) {
- return(1);
+ return 1;
}
+
while((ent = readdir(dir)) != NULL) {
const char *name = ent->d_name;
@@ -354,44 +355,43 @@ static int dir_belongsto_pkg(const char *dirpath, pmpkg_t *pkg)
continue;
}
snprintf(path, PATH_MAX, "%s/%s", dirpath, name);
- snprintf(abspath, PATH_MAX, "%s%s", handle->root, path);
+ snprintf(abspath, PATH_MAX, "%s%s", root, path);
if(stat(abspath, &sbuf) != 0) {
continue;
}
if(S_ISDIR(sbuf.st_mode)) {
- if(dir_belongsto_pkg(path, pkg)) {
+ if(dir_belongsto_pkg(root, path, pkg)) {
continue;
} else {
closedir(dir);
- return(0);
+ return 0;
}
} else {
- if(alpm_list_find_str(alpm_pkg_get_files(pkg), path)) {
+ if(_alpm_filelist_contains(alpm_pkg_get_files(pkg), path)) {
continue;
} else {
closedir(dir);
- return(0);
+ return 0;
}
}
}
closedir(dir);
- return(1);
+ return 1;
}
/* Find file conflicts that may occur during the transaction with two checks:
* 1: check every target against every target
* 2: check every target against the filesystem */
-alpm_list_t *_alpm_db_find_fileconflicts(pmdb_t *db, pmtrans_t *trans,
+alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
alpm_list_t *upgrade, alpm_list_t *remove)
{
- alpm_list_t *i, *j, *conflicts = NULL;
+ alpm_list_t *i, *conflicts = NULL;
size_t numtargs = alpm_list_count(upgrade);
size_t current;
+ alpm_trans_t *trans = handle->trans;
- ALPM_LOG_FUNC;
-
- if(db == NULL || upgrade == NULL || trans == NULL) {
- return(NULL);
+ if(!upgrade) {
+ return NULL;
}
/* TODO this whole function needs a huge change, which hopefully will
@@ -399,61 +399,75 @@ alpm_list_t *_alpm_db_find_fileconflicts(pmdb_t *db, pmtrans_t *trans,
* here as we do when we actually extract files in add.c with our 12
* different cases. */
for(current = 0, i = upgrade; i; i = i->next, current++) {
- alpm_list_t *k, *tmpfiles = NULL;
- pmpkg_t *p1, *p2, *dbpkg;
- char path[PATH_MAX+1];
-
- p1 = i->data;
- if(!p1) {
- continue;
- }
+ alpm_pkg_t *p1 = i->data;
+ alpm_list_t *j;
+ alpm_filelist_t tmpfiles;
+ alpm_pkg_t *dbpkg;
+ size_t filenum;
int percent = (current * 100) / numtargs;
- PROGRESS(trans, PM_TRANS_PROGRESS_CONFLICTS_START, "", percent,
+ PROGRESS(trans, ALPM_TRANS_PROGRESS_CONFLICTS_START, "", percent,
numtargs, current);
/* CHECK 1: check every target against every target */
- _alpm_log(PM_LOG_DEBUG, "searching for file conflicts: %s\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "searching for file conflicts: %s\n",
alpm_pkg_get_name(p1));
for(j = i->next; j; j = j->next) {
- p2 = j->data;
- if(!p2) {
- continue;
- }
- tmpfiles = chk_fileconflicts(alpm_pkg_get_files(p1), alpm_pkg_get_files(p2));
-
- if(tmpfiles) {
- for(k = tmpfiles; k; k = k->next) {
+ alpm_list_t *common_files;
+ alpm_pkg_t *p2 = j->data;
+ common_files = filelist_operation(alpm_pkg_get_files(p1),
+ alpm_pkg_get_files(p2), INTERSECT);
+
+ if(common_files) {
+ alpm_list_t *k;
+ char path[PATH_MAX];
+ for(k = common_files; k; k = k->next) {
snprintf(path, PATH_MAX, "%s%s", handle->root, (char *)k->data);
- conflicts = add_fileconflict(conflicts, PM_FILECONFLICT_TARGET, path,
+ conflicts = add_fileconflict(handle, conflicts,
+ ALPM_FILECONFLICT_TARGET, path,
alpm_pkg_get_name(p1), alpm_pkg_get_name(p2));
+ if(handle->pm_errno == ALPM_ERR_MEMORY) {
+ FREELIST(conflicts);
+ FREELIST(common_files);
+ return NULL;
+ }
}
- FREELIST(tmpfiles);
+ alpm_list_free(common_files);
}
}
- /* declarations for second check */
- struct stat lsbuf, sbuf;
-
/* CHECK 2: check every target against the filesystem */
- _alpm_log(PM_LOG_DEBUG, "searching for filesystem conflicts: %s\n", p1->name);
- dbpkg = _alpm_db_get_pkgfromcache(db, p1->name);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "searching for filesystem conflicts: %s\n",
+ p1->name);
+ dbpkg = _alpm_db_get_pkgfromcache(handle->db_local, p1->name);
/* Do two different checks here. If the package is currently installed,
* then only check files that are new in the new package. If the package
- * is not currently installed, then simply stat the whole filelist */
+ * is not currently installed, then simply stat the whole filelist. Note
+ * that the former list needs to be freed while the latter list should NOT
+ * be freed. */
if(dbpkg) {
+ alpm_list_t *difference;
/* older ver of package currently installed */
- tmpfiles = chk_filedifference(alpm_pkg_get_files(p1),
- alpm_pkg_get_files(dbpkg));
+ difference = filelist_operation(alpm_pkg_get_files(p1),
+ alpm_pkg_get_files(dbpkg), DIFFERENCE);
+ tmpfiles.count = alpm_list_count(difference);
+ tmpfiles.files = alpm_list_to_array(difference, tmpfiles.count,
+ sizeof(alpm_file_t));
+ alpm_list_free(difference);
} else {
/* no version of package currently installed */
- tmpfiles = alpm_list_strdup(alpm_pkg_get_files(p1));
+ tmpfiles = *alpm_pkg_get_files(p1);
}
- for(j = tmpfiles; j; j = j->next) {
- const char *filestr = j->data, *relative_path;
+ for(filenum = 0; filenum < tmpfiles.count; filenum++) {
+ alpm_file_t *file = tmpfiles.files + filenum;
+ const char *filestr = file->name;
+ const char *relative_path;
+ alpm_list_t *k;
/* have we acted on this conflict? */
int resolved_conflict = 0;
+ struct stat lsbuf;
+ char path[PATH_MAX];
snprintf(path, PATH_MAX, "%s%s", handle->root, filestr);
@@ -461,14 +475,16 @@ alpm_list_t *_alpm_db_find_fileconflicts(pmdb_t *db, pmtrans_t *trans,
if(_alpm_lstat(path, &lsbuf) != 0) {
continue;
}
- stat(path, &sbuf);
- if(path[strlen(path) - 1] == '/') {
+ if(S_ISDIR(file->mode)) {
+ struct stat sbuf;
if(S_ISDIR(lsbuf.st_mode)) {
- _alpm_log(PM_LOG_DEBUG, "%s is a directory, not a conflict\n", path);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "%s is a directory, not a conflict\n", path);
continue;
- } else if(S_ISLNK(lsbuf.st_mode) && S_ISDIR(sbuf.st_mode)) {
- _alpm_log(PM_LOG_DEBUG,
+ }
+ stat(path, &sbuf);
+ if(S_ISLNK(lsbuf.st_mode) && S_ISDIR(sbuf.st_mode)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
"%s is a symlink to a dir, hopefully not a conflict\n", path);
continue;
}
@@ -478,38 +494,37 @@ alpm_list_t *_alpm_db_find_fileconflicts(pmdb_t *db, pmtrans_t *trans,
path[strlen(path) - 1] = '\0';
}
- _alpm_log(PM_LOG_DEBUG, "checking possible conflict: %s\n", path);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "checking possible conflict: %s\n", path);
relative_path = path + strlen(handle->root);
/* Check remove list (will we remove the conflicting local file?) */
for(k = remove; k && !resolved_conflict; k = k->next) {
- pmpkg_t *rempkg = k->data;
- if(alpm_list_find_str(alpm_pkg_get_files(rempkg), relative_path)) {
- _alpm_log(PM_LOG_DEBUG,
- "local file will be removed, not a conflict: %s\n",
- relative_path);
+ alpm_pkg_t *rempkg = k->data;
+ if(rempkg && _alpm_filelist_contains(alpm_pkg_get_files(rempkg),
+ relative_path)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "local file will be removed, not a conflict: %s\n", path);
resolved_conflict = 1;
}
}
/* Look at all the targets to see if file has changed hands */
for(k = upgrade; k && !resolved_conflict; k = k->next) {
- p2 = k->data;
+ alpm_pkg_t *p2 = k->data;
if(!p2 || strcmp(p1->name, p2->name) == 0) {
continue;
}
- pmpkg_t *localp2 = _alpm_db_get_pkgfromcache(db, p2->name);
+ alpm_pkg_t *localp2 = _alpm_db_get_pkgfromcache(handle->db_local, p2->name);
/* localp2->files will be removed (target conflicts are handled by CHECK 1) */
- if(localp2 && alpm_list_find_str(alpm_pkg_get_files(localp2), filestr)) {
+ if(localp2 && _alpm_filelist_contains(alpm_pkg_get_files(localp2), filestr)) {
/* skip removal of file, but not add. this will prevent a second
* package from removing the file when it was already installed
* by its new owner (whether the file is in backup array or not */
- trans->skip_remove = alpm_list_add(trans->skip_remove,
- strdup(filestr));
- _alpm_log(PM_LOG_DEBUG,
- "file changed packages, adding to remove skiplist: %s\n",
- filestr);
+ handle->trans->skip_remove =
+ alpm_list_add(handle->trans->skip_remove, strdup(filestr));
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "file changed packages, adding to remove skiplist: %s\n", path);
resolved_conflict = 1;
}
}
@@ -518,115 +533,67 @@ alpm_list_t *_alpm_db_find_fileconflicts(pmdb_t *db, pmtrans_t *trans,
if(!resolved_conflict && S_ISDIR(lsbuf.st_mode) && dbpkg) {
char *dir = malloc(strlen(filestr) + 2);
sprintf(dir, "%s/", filestr);
- if(alpm_list_find_str(alpm_pkg_get_files(dbpkg),dir)) {
- _alpm_log(PM_LOG_DEBUG, "check if all files in %s belongs to %s\n",
+ if(_alpm_filelist_contains(alpm_pkg_get_files(dbpkg), dir)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "check if all files in %s belongs to %s\n",
dir, dbpkg->name);
- resolved_conflict = dir_belongsto_pkg(filestr, dbpkg);
+ resolved_conflict = dir_belongsto_pkg(handle->root, filestr, dbpkg);
}
free(dir);
}
if(!resolved_conflict && dbpkg) {
- char *rpath = calloc(PATH_MAX+1, sizeof(char));
+ char *rpath = calloc(PATH_MAX, sizeof(char));
const char *relative_rpath;
if(!realpath(path, rpath)) {
free(rpath);
continue;
}
relative_rpath = rpath + strlen(handle->root);
- if(alpm_list_find_str(alpm_pkg_get_files(dbpkg), relative_rpath)) {
+ if(_alpm_filelist_contains(alpm_pkg_get_files(dbpkg), relative_rpath)) {
resolved_conflict = 1;
}
free(rpath);
}
+ /* is the file unowned and in the backup list of the new package? */
+ if(!resolved_conflict && _alpm_needbackup(filestr, p1)) {
+ alpm_list_t *local_pkgs = _alpm_db_get_pkgcache(handle->db_local);
+ int found = 0;
+ for(k = local_pkgs; k && !found; k = k->next) {
+ if(_alpm_filelist_contains(alpm_pkg_get_files(k->data), filestr)) {
+ found = 1;
+ }
+ }
+ if(!found) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "file was unowned but in new backup list: %s\n", path);
+ resolved_conflict = 1;
+ }
+ }
+
if(!resolved_conflict) {
- conflicts = add_fileconflict(conflicts, PM_FILECONFLICT_FILESYSTEM,
- path, p1->name, NULL);
+ conflicts = add_fileconflict(handle, conflicts,
+ ALPM_FILECONFLICT_FILESYSTEM, path, p1->name, NULL);
+ if(handle->pm_errno == ALPM_ERR_MEMORY) {
+ FREELIST(conflicts);
+ if(dbpkg) {
+ /* only freed if it was generated from filelist_operation() */
+ free(tmpfiles.files);
+ }
+ return NULL;
+ }
}
}
- FREELIST(tmpfiles);
+ if(dbpkg) {
+ /* only freed if it was generated from filelist_operation() */
+ free(tmpfiles.files);
+ }
}
- PROGRESS(trans, PM_TRANS_PROGRESS_CONFLICTS_START, "", 100,
+ PROGRESS(trans, ALPM_TRANS_PROGRESS_CONFLICTS_START, "", 100,
numtargs, current);
- return(conflicts);
+ return conflicts;
}
-const char SYMEXPORT *alpm_conflict_get_package1(pmconflict_t *conflict)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(conflict != NULL, return(NULL));
-
- return conflict->package1;
-}
-
-const char SYMEXPORT *alpm_conflict_get_package2(pmconflict_t *conflict)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(conflict != NULL, return(NULL));
-
- return conflict->package2;
-}
-
-const char SYMEXPORT *alpm_conflict_get_reason(pmconflict_t *conflict)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(conflict != NULL, return(NULL));
-
- return conflict->reason;
-}
-
-const char SYMEXPORT *alpm_fileconflict_get_target(pmfileconflict_t *conflict)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(conflict != NULL, return(NULL));
-
- return conflict->target;
-}
-
-pmfileconflicttype_t SYMEXPORT alpm_fileconflict_get_type(pmfileconflict_t *conflict)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(-1));
- ASSERT(conflict != NULL, return(-1));
-
- return conflict->type;
-}
-
-const char SYMEXPORT *alpm_fileconflict_get_file(pmfileconflict_t *conflict)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(conflict != NULL, return(NULL));
-
- return conflict->file;
-}
-
-const char SYMEXPORT *alpm_fileconflict_get_ctarget(pmfileconflict_t *conflict)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(conflict != NULL, return(NULL));
-
- return conflict->ctarget;
-}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/conflict.h b/lib/libalpm/conflict.h
index 418d3f61..8b7471fd 100644
--- a/lib/libalpm/conflict.h
+++ b/lib/libalpm/conflict.h
@@ -24,28 +24,17 @@
#include "db.h"
#include "package.h"
-struct __pmconflict_t {
- char *package1;
- char *package2;
- char *reason;
-};
+alpm_conflict_t *_alpm_conflict_dup(const alpm_conflict_t *conflict);
+void _alpm_conflict_free(alpm_conflict_t *conflict);
+alpm_list_t *_alpm_innerconflicts(alpm_handle_t *handle, alpm_list_t *packages);
+alpm_list_t *_alpm_outerconflicts(alpm_db_t *db, alpm_list_t *packages);
+alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
+ alpm_list_t *upgrade, alpm_list_t *remove);
-struct __pmfileconflict_t {
- char *target;
- pmfileconflicttype_t type;
- char *file;
- char *ctarget;
-};
+void _alpm_fileconflict_free(alpm_fileconflict_t *conflict);
-pmconflict_t *_alpm_conflict_new(const char *package1, const char *package2, const char *reason);
-pmconflict_t *_alpm_conflict_dup(const pmconflict_t *conflict);
-void _alpm_conflict_free(pmconflict_t *conflict);
-alpm_list_t *_alpm_innerconflicts(alpm_list_t *packages);
-alpm_list_t *_alpm_outerconflicts(pmdb_t *db, alpm_list_t *packages);
-alpm_list_t *_alpm_db_find_fileconflicts(pmdb_t *db, pmtrans_t *trans,
- alpm_list_t *upgrade, alpm_list_t *remove);
-
-void _alpm_fileconflict_free(pmfileconflict_t *conflict);
+const alpm_file_t *_alpm_filelist_contains(alpm_filelist_t *filelist,
+ const char *name);
#endif /* _ALPM_CONFLICT_H */
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: */
diff --git a/lib/libalpm/db.h b/lib/libalpm/db.h
index 75776d71..a09c7e26 100644
--- a/lib/libalpm/db.h
+++ b/lib/libalpm/db.h
@@ -22,81 +22,88 @@
#ifndef _ALPM_DB_H
#define _ALPM_DB_H
-#include "alpm.h"
-#include "pkghash.h"
-
#include <time.h>
/* libarchive */
#include <archive.h>
#include <archive_entry.h>
+#include "alpm.h"
+#include "pkghash.h"
+#include "signing.h"
+
/* Database entries */
-typedef enum _pmdbinfrq_t {
+typedef enum _alpm_dbinfrq_t {
INFRQ_BASE = 1,
INFRQ_DESC = (1 << 1),
INFRQ_FILES = (1 << 2),
INFRQ_SCRIPTLET = (1 << 3),
INFRQ_DSIZE = (1 << 4),
/* ALL should be info stored in the package or database */
- INFRQ_ALL = 0x1F
-} pmdbinfrq_t;
+ INFRQ_ALL = 0x1F,
+ INFRQ_ERROR = (1 << 31)
+} alpm_dbinfrq_t;
+
+/** Database status. Bitflags. */
+enum _alpm_dbstatus_t {
+ DB_STATUS_VALID = (1 << 0),
+ DB_STATUS_PKGCACHE = (1 << 1),
+ DB_STATUS_GRPCACHE = (1 << 2)
+};
struct db_operations {
- int (*populate) (pmdb_t *);
- void (*unregister) (pmdb_t *);
- int (*version) (pmdb_t *);
+ int (*validate) (alpm_db_t *);
+ int (*populate) (alpm_db_t *);
+ void (*unregister) (alpm_db_t *);
};
/* Database */
-struct __pmdb_t {
+struct __alpm_db_t {
+ alpm_handle_t *handle;
char *treename;
/* do not access directly, use _alpm_db_path(db) for lazy access */
char *_path;
- int pkgcache_loaded;
- int grpcache_loaded;
/* also indicates whether we are RO or RW */
int is_local;
- pmpkghash_t *pkgcache;
+ /* flags determining validity, loaded caches, etc. */
+ enum _alpm_dbstatus_t status;
+ alpm_pkghash_t *pkgcache;
alpm_list_t *grpcache;
alpm_list_t *servers;
+ alpm_siglevel_t siglevel;
struct db_operations *ops;
};
/* db.c, database general calls */
-pmdb_t *_alpm_db_new(const char *treename, int is_local);
-void _alpm_db_free(pmdb_t *db);
-const char *_alpm_db_path(pmdb_t *db);
-int _alpm_db_version(pmdb_t *db);
+alpm_db_t *_alpm_db_new(const char *treename, int is_local);
+void _alpm_db_free(alpm_db_t *db);
+const char *_alpm_db_path(alpm_db_t *db);
+char *_alpm_db_sig_path(alpm_db_t *db);
int _alpm_db_cmp(const void *d1, const void *d2);
-alpm_list_t *_alpm_db_search(pmdb_t *db, const alpm_list_t *needles);
-pmdb_t *_alpm_db_register_local(void);
-pmdb_t *_alpm_db_register_sync(const char *treename);
-void _alpm_db_unregister(pmdb_t *db);
+alpm_list_t *_alpm_db_search(alpm_db_t *db, const alpm_list_t *needles);
+alpm_db_t *_alpm_db_register_local(alpm_handle_t *handle);
+alpm_db_t *_alpm_db_register_sync(alpm_handle_t *handle, const char *treename,
+ alpm_siglevel_t level);
+void _alpm_db_unregister(alpm_db_t *db);
/* be_*.c, backend specific calls */
-int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq);
-int _alpm_local_db_prepare(pmdb_t *db, pmpkg_t *info);
-int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq);
-int _alpm_local_db_remove(pmdb_t *db, pmpkg_t *info);
+int _alpm_local_db_prepare(alpm_db_t *db, alpm_pkg_t *info);
+int _alpm_local_db_write(alpm_db_t *db, alpm_pkg_t *info, alpm_dbinfrq_t inforeq);
+int _alpm_local_db_remove(alpm_db_t *db, alpm_pkg_t *info);
/* cache bullshit */
/* packages */
-int _alpm_db_load_pkgcache(pmdb_t *db);
-void _alpm_db_free_pkgcache(pmdb_t *db);
-int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg);
-int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg);
-pmpkghash_t *_alpm_db_get_pkgcache_hash(pmdb_t *db);
-alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db);
-int _alpm_db_ensure_pkgcache(pmdb_t *db, pmdbinfrq_t infolevel);
-pmpkg_t *_alpm_db_get_pkgfromcache(pmdb_t *db, const char *target);
+void _alpm_db_free_pkgcache(alpm_db_t *db);
+int _alpm_db_add_pkgincache(alpm_db_t *db, alpm_pkg_t *pkg);
+int _alpm_db_remove_pkgfromcache(alpm_db_t *db, alpm_pkg_t *pkg);
+alpm_pkghash_t *_alpm_db_get_pkgcache_hash(alpm_db_t *db);
+alpm_list_t *_alpm_db_get_pkgcache(alpm_db_t *db);
+alpm_pkg_t *_alpm_db_get_pkgfromcache(alpm_db_t *db, const char *target);
/* groups */
-int _alpm_db_load_grpcache(pmdb_t *db);
-void _alpm_db_free_grpcache(pmdb_t *db);
-alpm_list_t *_alpm_db_get_grpcache(pmdb_t *db);
-pmgrp_t *_alpm_db_get_grpfromcache(pmdb_t *db, const char *target);
+alpm_list_t *_alpm_db_get_groupcache(alpm_db_t *db);
+alpm_group_t *_alpm_db_get_groupfromcache(alpm_db_t *db, const char *target);
#endif /* _ALPM_DB_H */
diff --git a/lib/libalpm/delta.c b/lib/libalpm/delta.c
index 10c982f2..1b7e3eec 100644
--- a/lib/libalpm/delta.c
+++ b/lib/libalpm/delta.c
@@ -34,51 +34,18 @@
#include "log.h"
#include "graph.h"
-/** \addtogroup alpm_deltas Delta Functions
- * @brief Functions to manipulate libalpm deltas
- * @{
- */
-
-const char SYMEXPORT *alpm_delta_get_from(pmdelta_t *delta)
-{
- ASSERT(delta != NULL, return(NULL));
- return(delta->from);
-}
-
-const char SYMEXPORT *alpm_delta_get_to(pmdelta_t *delta)
-{
- ASSERT(delta != NULL, return(NULL));
- return(delta->to);
-}
-
-const char SYMEXPORT *alpm_delta_get_filename(pmdelta_t *delta)
-{
- ASSERT(delta != NULL, return(NULL));
- return(delta->delta);
-}
-
-const char SYMEXPORT *alpm_delta_get_md5sum(pmdelta_t *delta)
-{
- ASSERT(delta != NULL, return(NULL));
- return(delta->delta_md5);
-}
-
-off_t SYMEXPORT alpm_delta_get_size(pmdelta_t *delta)
-{
- ASSERT(delta != NULL, return(-1));
- return(delta->delta_size);
-}
-
-/** @} */
-
static alpm_list_t *graph_init(alpm_list_t *deltas, int reverse)
{
alpm_list_t *i, *j;
alpm_list_t *vertices = NULL;
/* create the vertices */
for(i = deltas; i; i = i->next) {
- pmgraph_t *v = _alpm_graph_new();
- pmdelta_t *vdelta = i->data;
+ alpm_graph_t *v = _alpm_graph_new();
+ if(!v) {
+ alpm_list_free(vertices);
+ return NULL;
+ }
+ alpm_delta_t *vdelta = i->data;
vdelta->download_size = vdelta->delta_size;
v->weight = LONG_MAX;
v->data = vdelta;
@@ -87,12 +54,12 @@ static alpm_list_t *graph_init(alpm_list_t *deltas, int reverse)
/* compute the edges */
for(i = vertices; i; i = i->next) {
- pmgraph_t *v_i = i->data;
- pmdelta_t *d_i = v_i->data;
+ alpm_graph_t *v_i = i->data;
+ alpm_delta_t *d_i = v_i->data;
/* loop a second time so we make all possible comparisons */
for(j = vertices; j; j = j->next) {
- pmgraph_t *v_j = j->data;
- pmdelta_t *d_j = v_j->data;
+ alpm_graph_t *v_j = j->data;
+ alpm_delta_t *d_j = v_j->data;
/* We want to create a delta tree like the following:
* 1_to_2
* |
@@ -108,20 +75,20 @@ static alpm_list_t *graph_init(alpm_list_t *deltas, int reverse)
}
v_i->childptr = v_i->children;
}
- return(vertices);
+ return vertices;
}
-static void graph_init_size(alpm_list_t *vertices)
+static void graph_init_size(alpm_handle_t *handle, alpm_list_t *vertices)
{
alpm_list_t *i;
for(i = vertices; i; i = i->next) {
char *fpath, *md5sum;
- pmgraph_t *v = i->data;
- pmdelta_t *vdelta = v->data;
+ alpm_graph_t *v = i->data;
+ alpm_delta_t *vdelta = v->data;
/* determine whether the delta file already exists */
- fpath = _alpm_filecache_find(vdelta->delta);
+ fpath = _alpm_filecache_find(handle, vdelta->delta);
md5sum = alpm_compute_md5sum(fpath);
if(fpath && md5sum && strcmp(md5sum, vdelta->delta_md5) == 0) {
vdelta->download_size = 0;
@@ -130,7 +97,7 @@ static void graph_init_size(alpm_list_t *vertices)
FREE(md5sum);
/* determine whether a base 'from' file exists */
- fpath = _alpm_filecache_find(vdelta->from);
+ fpath = _alpm_filecache_find(handle, vdelta->from);
if(fpath) {
v->weight = vdelta->download_size;
}
@@ -142,12 +109,12 @@ static void graph_init_size(alpm_list_t *vertices)
static void dijkstra(alpm_list_t *vertices)
{
alpm_list_t *i;
- pmgraph_t *v;
+ alpm_graph_t *v;
while(1) {
v = NULL;
/* find the smallest vertice not visited yet */
for(i = vertices; i; i = i->next) {
- pmgraph_t *v_i = i->data;
+ alpm_graph_t *v_i = i->data;
if(v_i->state == -1) {
continue;
@@ -165,8 +132,8 @@ static void dijkstra(alpm_list_t *vertices)
v->childptr = v->children;
while(v->childptr) {
- pmgraph_t *v_c = v->childptr->data;
- pmdelta_t *d_c = v_c->data;
+ alpm_graph_t *v_c = v->childptr->data;
+ alpm_delta_t *d_c = v_c->data;
if(v_c->weight > v->weight + d_c->download_size) {
v_c->weight = v->weight + d_c->download_size;
v_c->parent = v;
@@ -181,13 +148,13 @@ static void dijkstra(alpm_list_t *vertices)
static off_t shortest_path(alpm_list_t *vertices, const char *to, alpm_list_t **path)
{
alpm_list_t *i;
- pmgraph_t *v = NULL;
+ alpm_graph_t *v = NULL;
off_t bestsize = 0;
alpm_list_t *rpath = NULL;
for(i = vertices; i; i = i->next) {
- pmgraph_t *v_i = i->data;
- pmdelta_t *d_i = v_i->data;
+ alpm_graph_t *v_i = i->data;
+ alpm_delta_t *d_i = v_i->data;
if(strcmp(d_i->to, to) == 0) {
if(v == NULL || v_i->weight < v->weight) {
@@ -198,54 +165,53 @@ static off_t shortest_path(alpm_list_t *vertices, const char *to, alpm_list_t **
}
while(v != NULL) {
- pmdelta_t *vdelta = v->data;
+ alpm_delta_t *vdelta = v->data;
rpath = alpm_list_add(rpath, vdelta);
v = v->parent;
}
*path = alpm_list_reverse(rpath);
alpm_list_free(rpath);
- return(bestsize);
+ return bestsize;
}
/** Calculates the shortest path from one version to another.
* The shortest path is defined as the path with the smallest combined
* size, not the length of the path.
- * @param deltas the list of pmdelta_t * objects that a file has
+ * @param handle the context handle
+ * @param deltas the list of alpm_delta_t * objects that a file has
* @param to the file to start the search at
- * @param path the pointer to a list location where pmdelta_t * objects that
+ * @param path the pointer to a list location where alpm_delta_t * objects that
* have the smallest size are placed. NULL is set if there is no path
* possible with the files available.
* @return the size of the path stored, or LONG_MAX if path is unfindable
*/
-off_t _alpm_shortest_delta_path(alpm_list_t *deltas,
+off_t _alpm_shortest_delta_path(alpm_handle_t *handle, alpm_list_t *deltas,
const char *to, alpm_list_t **path)
{
alpm_list_t *bestpath = NULL;
alpm_list_t *vertices;
off_t bestsize = LONG_MAX;
- ALPM_LOG_FUNC;
-
if(deltas == NULL) {
*path = NULL;
- return(bestsize);
+ return bestsize;
}
- _alpm_log(PM_LOG_DEBUG, "started delta shortest-path search for '%s'\n", to);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "started delta shortest-path search for '%s'\n", to);
vertices = graph_init(deltas, 0);
- graph_init_size(vertices);
+ graph_init_size(handle, vertices);
dijkstra(vertices);
bestsize = shortest_path(vertices, to, &bestpath);
- _alpm_log(PM_LOG_DEBUG, "delta shortest-path search complete : '%jd'\n", (intmax_t)bestsize);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "delta shortest-path search complete : '%jd'\n", (intmax_t)bestsize);
alpm_list_free_inner(vertices, _alpm_graph_free);
alpm_list_free(vertices);
*path = bestpath;
- return(bestsize);
+ return bestsize;
}
static alpm_list_t *find_unused(alpm_list_t *deltas, const char *to, off_t quota)
@@ -256,8 +222,8 @@ static alpm_list_t *find_unused(alpm_list_t *deltas, const char *to, off_t quota
vertices = graph_init(deltas, 1);
for(i = vertices; i; i = i->next) {
- pmgraph_t *v = i->data;
- pmdelta_t *vdelta = v->data;
+ alpm_graph_t *v = i->data;
+ alpm_delta_t *vdelta = v->data;
if(strcmp(vdelta->to, to) == 0)
{
v->weight = vdelta->download_size;
@@ -265,39 +231,45 @@ static alpm_list_t *find_unused(alpm_list_t *deltas, const char *to, off_t quota
}
dijkstra(vertices);
for(i = vertices; i; i = i->next) {
- pmgraph_t *v = i->data;
- pmdelta_t *vdelta = v->data;
+ alpm_graph_t *v = i->data;
+ alpm_delta_t *vdelta = v->data;
if(v->weight > quota) {
unused = alpm_list_add(unused, vdelta->delta);
}
}
alpm_list_free_inner(vertices, _alpm_graph_free);
alpm_list_free(vertices);
- return(unused);
+ return unused;
}
-alpm_list_t SYMEXPORT *alpm_pkg_unused_deltas(pmpkg_t *pkg)
+/** \addtogroup alpm_deltas Delta Functions
+ * @brief Functions to manipulate libalpm deltas
+ * @{
+ */
+
+alpm_list_t SYMEXPORT *alpm_pkg_unused_deltas(alpm_pkg_t *pkg)
{
off_t pkgsize = alpm_pkg_get_size(pkg);
alpm_list_t *unused = find_unused(
alpm_pkg_get_deltas(pkg),
alpm_pkg_get_filename(pkg),
pkgsize * MAX_DELTA_RATIO);
- return(unused);
+ return unused;
}
+/** @} */
-/** Parses the string representation of a pmdelta_t object.
+/** Parses the string representation of a alpm_delta_t object.
* This function assumes that the string is in the correct format.
* This format is as follows:
* $deltafile $deltamd5 $deltasize $oldfile $newfile
* @param line the string to parse
- * @return A pointer to the new pmdelta_t object
+ * @return A pointer to the new alpm_delta_t object
*/
/* TODO this does not really belong here, but in a parsing lib */
-pmdelta_t *_alpm_delta_parse(char *line)
+alpm_delta_t *_alpm_delta_parse(char *line)
{
- pmdelta_t *delta;
+ alpm_delta_t *delta;
char *tmp = line, *tmp2;
regex_t reg;
@@ -308,21 +280,21 @@ pmdelta_t *_alpm_delta_parse(char *line)
if(regexec(&reg, line, 0, 0, 0) != 0) {
/* delta line is invalid, return NULL */
regfree(&reg);
- return(NULL);
+ return NULL;
}
regfree(&reg);
- CALLOC(delta, 1, sizeof(pmdelta_t), RET_ERR(PM_ERR_MEMORY, NULL));
+ CALLOC(delta, 1, sizeof(alpm_delta_t), return NULL);
tmp2 = tmp;
tmp = strchr(tmp, ' ');
*(tmp++) = '\0';
- STRDUP(delta->delta, tmp2, RET_ERR(PM_ERR_MEMORY, NULL));
+ STRDUP(delta->delta, tmp2, return NULL);
tmp2 = tmp;
tmp = strchr(tmp, ' ');
*(tmp++) = '\0';
- STRDUP(delta->delta_md5, tmp2, RET_ERR(PM_ERR_MEMORY, NULL));
+ STRDUP(delta->delta_md5, tmp2, return NULL);
tmp2 = tmp;
tmp = strchr(tmp, ' ');
@@ -332,23 +304,35 @@ pmdelta_t *_alpm_delta_parse(char *line)
tmp2 = tmp;
tmp = strchr(tmp, ' ');
*(tmp++) = '\0';
- STRDUP(delta->from, tmp2, RET_ERR(PM_ERR_MEMORY, NULL));
+ STRDUP(delta->from, tmp2, return NULL);
tmp2 = tmp;
- STRDUP(delta->to, tmp2, RET_ERR(PM_ERR_MEMORY, NULL));
-
- _alpm_log(PM_LOG_DEBUG, "delta : %s %s '%jd'\n", delta->from, delta->to, (intmax_t)delta->delta_size);
+ STRDUP(delta->to, tmp2, return NULL);
- return(delta);
+ return delta;
}
-void _alpm_delta_free(pmdelta_t *delta)
+void _alpm_delta_free(alpm_delta_t *delta)
{
- FREE(delta->from);
- FREE(delta->to);
FREE(delta->delta);
FREE(delta->delta_md5);
+ FREE(delta->from);
+ FREE(delta->to);
FREE(delta);
}
+alpm_delta_t *_alpm_delta_dup(const alpm_delta_t *delta)
+{
+ alpm_delta_t *newdelta;
+ CALLOC(newdelta, 1, sizeof(alpm_delta_t), return NULL);
+ STRDUP(newdelta->delta, delta->delta, return NULL);
+ STRDUP(newdelta->delta_md5, delta->delta_md5, return NULL);
+ STRDUP(newdelta->from, delta->from, return NULL);
+ STRDUP(newdelta->to, delta->to, return NULL);
+ newdelta->delta_size = delta->delta_size;
+ newdelta->download_size = delta->download_size;
+
+ return newdelta;
+}
+
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/delta.h b/lib/libalpm/delta.h
index d7a81c47..05df4207 100644
--- a/lib/libalpm/delta.h
+++ b/lib/libalpm/delta.h
@@ -20,28 +20,16 @@
#ifndef _ALPM_DELTA_H
#define _ALPM_DELTA_H
+#include "config.h" /* ensure off_t is correct length */
+
#include <sys/types.h> /* off_t */
#include "alpm.h"
-struct __pmdelta_t {
- /** filename of the delta patch */
- char *delta;
- /** md5sum of the delta file */
- char *delta_md5;
- /** filesize of the delta file */
- off_t delta_size;
- /** filename of the 'before' file */
- char *from;
- /** filename of the 'after' file */
- char *to;
- /** download filesize of the delta file */
- off_t download_size;
-};
-
-pmdelta_t *_alpm_delta_parse(char *line);
-void _alpm_delta_free(pmdelta_t *delta);
-off_t _alpm_shortest_delta_path(alpm_list_t *deltas,
+alpm_delta_t *_alpm_delta_parse(char *line);
+void _alpm_delta_free(alpm_delta_t *delta);
+alpm_delta_t *_alpm_delta_dup(const alpm_delta_t *delta);
+off_t _alpm_shortest_delta_path(alpm_handle_t *handle, alpm_list_t *deltas,
const char *to, alpm_list_t **path);
/* max percent of package size to download deltas */
diff --git a/lib/libalpm/deps.c b/lib/libalpm/deps.c
index 36d6e1aa..c3681b34 100644
--- a/lib/libalpm/deps.c
+++ b/lib/libalpm/deps.c
@@ -35,31 +35,30 @@
#include "package.h"
#include "db.h"
#include "handle.h"
+#include "trans.h"
-void _alpm_dep_free(pmdepend_t *dep)
+void _alpm_dep_free(alpm_depend_t *dep)
{
FREE(dep->name);
FREE(dep->version);
FREE(dep);
}
-static pmdepmissing_t *depmiss_new(const char *target, pmdepend_t *dep,
+static alpm_depmissing_t *depmiss_new(const char *target, alpm_depend_t *dep,
const char *causingpkg)
{
- pmdepmissing_t *miss;
+ alpm_depmissing_t *miss;
- ALPM_LOG_FUNC;
+ MALLOC(miss, sizeof(alpm_depmissing_t), return NULL);
- MALLOC(miss, sizeof(pmdepmissing_t), RET_ERR(PM_ERR_MEMORY, NULL));
-
- STRDUP(miss->target, target, RET_ERR(PM_ERR_MEMORY, NULL));
+ STRDUP(miss->target, target, return NULL);
miss->depend = _alpm_dep_dup(dep);
- STRDUP(miss->causingpkg, causingpkg, RET_ERR(PM_ERR_MEMORY, NULL));
+ STRDUP(miss->causingpkg, causingpkg, return NULL);
- return(miss);
+ return miss;
}
-void _alpm_depmiss_free(pmdepmissing_t *miss)
+void _alpm_depmiss_free(alpm_depmissing_t *miss)
{
_alpm_dep_free(miss->depend);
FREE(miss->target);
@@ -68,18 +67,18 @@ void _alpm_depmiss_free(pmdepmissing_t *miss)
}
/* Does pkg1 depend on pkg2, ie. does pkg2 satisfy a dependency of pkg1? */
-static int _alpm_dep_edge(pmpkg_t *pkg1, pmpkg_t *pkg2)
+static int _alpm_dep_edge(alpm_pkg_t *pkg1, alpm_pkg_t *pkg2)
{
alpm_list_t *i;
for(i = alpm_pkg_get_depends(pkg1); i; i = i->next) {
if(_alpm_depcmp(pkg2, i->data)) {
- return(1);
+ return 1;
}
}
- return(0);
+ return 0;
}
-/* Convert a list of pmpkg_t * to a graph structure,
+/* Convert a list of alpm_pkg_t * to a graph structure,
* with a edge for each dependency.
* Returns a list of vertices (one vertex = one package)
* (used by alpm_sortbydeps)
@@ -90,19 +89,19 @@ static alpm_list_t *dep_graph_init(alpm_list_t *targets)
alpm_list_t *vertices = NULL;
/* We create the vertices */
for(i = targets; i; i = i->next) {
- pmgraph_t *vertex = _alpm_graph_new();
+ alpm_graph_t *vertex = _alpm_graph_new();
vertex->data = (void *)i->data;
vertices = alpm_list_add(vertices, vertex);
}
/* We compute the edges */
for(i = vertices; i; i = i->next) {
- pmgraph_t *vertex_i = i->data;
- pmpkg_t *p_i = vertex_i->data;
+ alpm_graph_t *vertex_i = i->data;
+ alpm_pkg_t *p_i = vertex_i->data;
/* TODO this should be somehow combined with alpm_checkdeps */
for(j = vertices; j; j = j->next) {
- pmgraph_t *vertex_j = j->data;
- pmpkg_t *p_j = vertex_j->data;
+ alpm_graph_t *vertex_j = j->data;
+ alpm_pkg_t *p_j = vertex_j->data;
if(_alpm_dep_edge(p_i, p_j)) {
vertex_i->children =
alpm_list_add(vertex_i->children, vertex_j);
@@ -110,7 +109,7 @@ static alpm_list_t *dep_graph_init(alpm_list_t *targets)
}
vertex_i->childptr = vertex_i->children;
}
- return(vertices);
+ return vertices;
}
/* Re-order a list of target packages with respect to their dependencies.
@@ -127,20 +126,19 @@ static alpm_list_t *dep_graph_init(alpm_list_t *targets)
* This function returns the new alpm_list_t* target list.
*
*/
-alpm_list_t *_alpm_sortbydeps(alpm_list_t *targets, int reverse)
+alpm_list_t *_alpm_sortbydeps(alpm_handle_t *handle,
+ alpm_list_t *targets, int reverse)
{
alpm_list_t *newtargs = NULL;
alpm_list_t *vertices = NULL;
alpm_list_t *vptr;
- pmgraph_t *vertex;
-
- ALPM_LOG_FUNC;
+ alpm_graph_t *vertex;
if(targets == NULL) {
- return(NULL);
+ return NULL;
}
- _alpm_log(PM_LOG_DEBUG, "started sorting dependencies\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "started sorting dependencies\n");
vertices = dep_graph_init(targets);
@@ -151,25 +149,25 @@ alpm_list_t *_alpm_sortbydeps(alpm_list_t *targets, int reverse)
vertex->state = -1;
int found = 0;
while(vertex->childptr && !found) {
- pmgraph_t *nextchild = vertex->childptr->data;
+ alpm_graph_t *nextchild = vertex->childptr->data;
vertex->childptr = vertex->childptr->next;
- if (nextchild->state == 0) {
+ if(nextchild->state == 0) {
found = 1;
nextchild->parent = vertex;
vertex = nextchild;
}
else if(nextchild->state == -1) {
- pmpkg_t *vertexpkg = vertex->data;
- pmpkg_t *childpkg = nextchild->data;
+ alpm_pkg_t *vertexpkg = vertex->data;
+ alpm_pkg_t *childpkg = nextchild->data;
const char *message;
- _alpm_log(PM_LOG_WARNING, _("dependency cycle detected:\n"));
+ _alpm_log(handle, ALPM_LOG_WARNING, _("dependency cycle detected:\n"));
if(reverse) {
message =_("%s will be removed after its %s dependency\n");
} else {
message =_("%s will be installed before its %s dependency\n");
}
- _alpm_log(PM_LOG_WARNING, message, vertexpkg->name, childpkg->name);
+ _alpm_log(handle, ALPM_LOG_WARNING, message, vertexpkg->name, childpkg->name);
}
}
if(!found) {
@@ -181,14 +179,14 @@ alpm_list_t *_alpm_sortbydeps(alpm_list_t *targets, int reverse)
vptr = vptr->next;
while(vptr) {
vertex = vptr->data;
- if (vertex->state == 0) break;
+ if(vertex->state == 0) break;
vptr = vptr->next;
}
}
}
}
- _alpm_log(PM_LOG_DEBUG, "sorting dependencies finished\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "sorting dependencies finished\n");
if(reverse) {
/* reverse the order */
@@ -201,108 +199,110 @@ alpm_list_t *_alpm_sortbydeps(alpm_list_t *targets, int reverse)
alpm_list_free_inner(vertices, _alpm_graph_free);
alpm_list_free(vertices);
- return(newtargs);
+ return newtargs;
}
-static int no_dep_version(void)
+static int no_dep_version(alpm_handle_t *handle)
{
- int flags = alpm_trans_get_flags();
- return flags != -1 && (flags & PM_TRANS_FLAG_NODEPVERSION);
+ int flags = alpm_trans_get_flags(handle);
+ return flags != -1 && (flags & ALPM_TRANS_FLAG_NODEPVERSION);
}
-static pmdepend_t *filtered_depend(pmdepend_t *dep, int nodepversion)
+static alpm_depend_t *filtered_depend(alpm_depend_t *dep, int nodepversion)
{
if(nodepversion) {
- pmdepend_t *newdep = _alpm_dep_dup(dep);
- ASSERT(newdep, return(dep));
- newdep->mod = PM_DEP_MOD_ANY;
+ alpm_depend_t *newdep = _alpm_dep_dup(dep);
+ ASSERT(newdep, return dep);
+ newdep->mod = ALPM_DEP_MOD_ANY;
dep = newdep;
}
return dep;
}
-static void release_filtered_depend(pmdepend_t *dep, int nodepversion)
+static void release_filtered_depend(alpm_depend_t *dep, int nodepversion)
{
if(nodepversion) {
free(dep);
}
}
-static pmpkg_t *find_dep_satisfier(alpm_list_t *pkgs, pmdepend_t *dep)
+static alpm_pkg_t *find_dep_satisfier(alpm_list_t *pkgs, alpm_depend_t *dep)
{
alpm_list_t *i;
for(i = pkgs; i; i = alpm_list_next(i)) {
- pmpkg_t *pkg = i->data;
+ alpm_pkg_t *pkg = i->data;
if(_alpm_depcmp(pkg, dep)) {
- return(pkg);
+ return pkg;
}
}
- return(NULL);
+ return NULL;
}
/** Find a package satisfying a specified dependency.
* The dependency can include versions with depmod operators.
- * @param pkgs an alpm_list_t* of pmpkg_t where the satisfier will be searched
+ * @param pkgs an alpm_list_t* of alpm_pkg_t where the satisfier will be searched
* @param depstring package or provision name, versioned or not
- * @return a pmpkg_t* satisfying depstring
+ * @return a alpm_pkg_t* satisfying depstring
*/
-pmpkg_t SYMEXPORT *alpm_find_satisfier(alpm_list_t *pkgs, const char *depstring)
+alpm_pkg_t SYMEXPORT *alpm_find_satisfier(alpm_list_t *pkgs, const char *depstring)
{
- pmdepend_t *dep = _alpm_splitdep(depstring);
- pmpkg_t *pkg = find_dep_satisfier(pkgs, dep);
+ alpm_depend_t *dep = _alpm_splitdep(depstring);
+ if(!dep) {
+ return NULL;
+ }
+ alpm_pkg_t *pkg = find_dep_satisfier(pkgs, dep);
_alpm_dep_free(dep);
- return(pkg);
+ return pkg;
}
/** Checks dependencies and returns missing ones in a list.
* Dependencies can include versions with depmod operators.
+ * @param handle the context handle
* @param pkglist the list of local packages
- * @param reversedeps handles the backward dependencies
* @param remove an alpm_list_t* of packages to be removed
* @param upgrade an alpm_list_t* of packages to be upgraded (remove-then-upgrade)
- * @return an alpm_list_t* of pmdepmissing_t pointers.
+ * @param reversedeps handles the backward dependencies
+ * @return an alpm_list_t* of alpm_depmissing_t pointers.
*/
-alpm_list_t SYMEXPORT *alpm_checkdeps(alpm_list_t *pkglist, int reversedeps,
- alpm_list_t *remove, alpm_list_t *upgrade)
+alpm_list_t SYMEXPORT *alpm_checkdeps(alpm_handle_t *handle, alpm_list_t *pkglist,
+ alpm_list_t *remove, alpm_list_t *upgrade, int reversedeps)
{
alpm_list_t *i, *j;
- alpm_list_t *targets, *dblist = NULL, *modified = NULL;
+ alpm_list_t *dblist = NULL, *modified = NULL;
alpm_list_t *baddeps = NULL;
int nodepversion;
- ALPM_LOG_FUNC;
+ CHECK_HANDLE(handle, return NULL);
- targets = alpm_list_join(alpm_list_copy(remove), alpm_list_copy(upgrade));
for(i = pkglist; i; i = i->next) {
- pmpkg_t *pkg = i->data;
- if(_alpm_pkg_find(targets, pkg->name)) {
+ alpm_pkg_t *pkg = i->data;
+ if(_alpm_pkg_find(remove, pkg->name) || _alpm_pkg_find(upgrade, pkg->name)) {
modified = alpm_list_add(modified, pkg);
} else {
dblist = alpm_list_add(dblist, pkg);
}
}
- alpm_list_free(targets);
- nodepversion = no_dep_version();
+ nodepversion = no_dep_version(handle);
/* look for unsatisfied dependencies of the upgrade list */
for(i = upgrade; i; i = i->next) {
- pmpkg_t *tp = i->data;
- _alpm_log(PM_LOG_DEBUG, "checkdeps: package %s-%s\n",
+ alpm_pkg_t *tp = i->data;
+ _alpm_log(handle, ALPM_LOG_DEBUG, "checkdeps: package %s-%s\n",
alpm_pkg_get_name(tp), alpm_pkg_get_version(tp));
for(j = alpm_pkg_get_depends(tp); j; j = j->next) {
- pmdepend_t *depend = j->data;
+ alpm_depend_t *depend = j->data;
depend = filtered_depend(depend, nodepversion);
/* 1. we check the upgrade list */
/* 2. we check database for untouched satisfying packages */
if(!find_dep_satisfier(upgrade, depend) &&
!find_dep_satisfier(dblist, depend)) {
/* Unsatisfied dependency in the upgrade list */
- pmdepmissing_t *miss;
+ alpm_depmissing_t *miss;
char *missdepstring = alpm_dep_compute_string(depend);
- _alpm_log(PM_LOG_DEBUG, "checkdeps: missing dependency '%s' for package '%s'\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "checkdeps: missing dependency '%s' for package '%s'\n",
missdepstring, alpm_pkg_get_name(tp));
free(missdepstring);
miss = depmiss_new(alpm_pkg_get_name(tp), depend, NULL);
@@ -316,20 +316,20 @@ alpm_list_t SYMEXPORT *alpm_checkdeps(alpm_list_t *pkglist, int reversedeps,
/* reversedeps handles the backwards dependencies, ie,
* the packages listed in the requiredby field. */
for(i = dblist; i; i = i->next) {
- pmpkg_t *lp = i->data;
+ alpm_pkg_t *lp = i->data;
for(j = alpm_pkg_get_depends(lp); j; j = j->next) {
- pmdepend_t *depend = j->data;
+ alpm_depend_t *depend = j->data;
depend = filtered_depend(depend, nodepversion);
- pmpkg_t *causingpkg = find_dep_satisfier(modified, depend);
+ alpm_pkg_t *causingpkg = find_dep_satisfier(modified, depend);
/* we won't break this depend, if it is already broken, we ignore it */
/* 1. check upgrade list for satisfiers */
/* 2. check dblist for satisfiers */
if(causingpkg &&
!find_dep_satisfier(upgrade, depend) &&
!find_dep_satisfier(dblist, depend)) {
- pmdepmissing_t *miss;
+ alpm_depmissing_t *miss;
char *missdepstring = alpm_dep_compute_string(depend);
- _alpm_log(PM_LOG_DEBUG, "checkdeps: transaction would break '%s' dependency of '%s'\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "checkdeps: transaction would break '%s' dependency of '%s'\n",
missdepstring, alpm_pkg_get_name(lp));
free(missdepstring);
miss = depmiss_new(lp->name, depend, alpm_pkg_get_name(causingpkg));
@@ -343,31 +343,31 @@ alpm_list_t SYMEXPORT *alpm_checkdeps(alpm_list_t *pkglist, int reversedeps,
alpm_list_free(modified);
alpm_list_free(dblist);
- return(baddeps);
+ return baddeps;
}
-static int dep_vercmp(const char *version1, pmdepmod_t mod,
+static int dep_vercmp(const char *version1, alpm_depmod_t mod,
const char *version2)
{
int equal = 0;
- if(mod == PM_DEP_MOD_ANY) {
+ if(mod == ALPM_DEP_MOD_ANY) {
equal = 1;
} else {
int cmp = alpm_pkg_vercmp(version1, version2);
switch(mod) {
- case PM_DEP_MOD_EQ: equal = (cmp == 0); break;
- case PM_DEP_MOD_GE: equal = (cmp >= 0); break;
- case PM_DEP_MOD_LE: equal = (cmp <= 0); break;
- case PM_DEP_MOD_LT: equal = (cmp < 0); break;
- case PM_DEP_MOD_GT: equal = (cmp > 0); break;
+ case ALPM_DEP_MOD_EQ: equal = (cmp == 0); break;
+ case ALPM_DEP_MOD_GE: equal = (cmp >= 0); break;
+ case ALPM_DEP_MOD_LE: equal = (cmp <= 0); break;
+ case ALPM_DEP_MOD_LT: equal = (cmp < 0); break;
+ case ALPM_DEP_MOD_GT: equal = (cmp > 0); break;
default: equal = 1; break;
}
}
- return(equal);
+ return equal;
}
-int _alpm_depcmp(pmpkg_t *pkg, pmdepend_t *dep)
+int _alpm_depcmp(alpm_pkg_t *pkg, alpm_depend_t *dep)
{
alpm_list_t *i;
int satisfy = 0;
@@ -380,7 +380,7 @@ int _alpm_depcmp(pmpkg_t *pkg, pmdepend_t *dep)
satisfy = (strcmp(pkg->name, dep->name) == 0
&& dep_vercmp(pkg->version, dep->mod, dep->version));
if(satisfy) {
- return(satisfy);
+ return satisfy;
}
}
@@ -390,7 +390,7 @@ int _alpm_depcmp(pmpkg_t *pkg, pmdepend_t *dep)
const char *provver = strchr(provision, '=');
if(provver == NULL) { /* no provision version */
- satisfy = (dep->mod == PM_DEP_MOD_ANY
+ satisfy = (dep->mod == ALPM_DEP_MOD_ANY
&& strcmp(provision, dep->name) == 0);
} else {
/* This is a bit tricker than the old code for performance reasons. To
@@ -406,86 +406,85 @@ int _alpm_depcmp(pmpkg_t *pkg, pmdepend_t *dep)
}
}
- return(satisfy);
+ return satisfy;
}
-pmdepend_t *_alpm_splitdep(const char *depstring)
+alpm_depend_t *_alpm_splitdep(const char *depstring)
{
- pmdepend_t *depend;
+ alpm_depend_t *depend;
const char *ptr, *version = NULL;
if(depstring == NULL) {
- return(NULL);
+ return NULL;
}
- CALLOC(depend, 1, sizeof(pmdepend_t), RET_ERR(PM_ERR_MEMORY, NULL));
+ CALLOC(depend, 1, sizeof(alpm_depend_t), return NULL);
/* Find a version comparator if one exists. If it does, set the type and
* increment the ptr accordingly so we can copy the right strings. */
if((ptr = strstr(depstring, ">="))) {
- depend->mod = PM_DEP_MOD_GE;
+ depend->mod = ALPM_DEP_MOD_GE;
version = ptr + 2;
} else if((ptr = strstr(depstring, "<="))) {
- depend->mod = PM_DEP_MOD_LE;
+ depend->mod = ALPM_DEP_MOD_LE;
version = ptr + 2;
} else if((ptr = strstr(depstring, "="))) {
/* Note: we must do =,<,> checks after <=, >= checks */
- depend->mod = PM_DEP_MOD_EQ;
+ depend->mod = ALPM_DEP_MOD_EQ;
version = ptr + 1;
} else if((ptr = strstr(depstring, "<"))) {
- depend->mod = PM_DEP_MOD_LT;
+ depend->mod = ALPM_DEP_MOD_LT;
version = ptr + 1;
} else if((ptr = strstr(depstring, ">"))) {
- depend->mod = PM_DEP_MOD_GT;
+ depend->mod = ALPM_DEP_MOD_GT;
version = ptr + 1;
} else {
/* no version specified, leave version and ptr NULL */
- depend->mod = PM_DEP_MOD_ANY;
+ depend->mod = ALPM_DEP_MOD_ANY;
}
/* copy the right parts to the right places */
- STRNDUP(depend->name, depstring, ptr - depstring,
- RET_ERR(PM_ERR_MEMORY, NULL));
+ STRNDUP(depend->name, depstring, ptr - depstring, return NULL);
depend->name_hash = _alpm_hash_sdbm(depend->name);
if(version) {
- STRDUP(depend->version, version, RET_ERR(PM_ERR_MEMORY, NULL));
+ STRDUP(depend->version, version, return NULL);
}
- return(depend);
+ return depend;
}
-pmdepend_t *_alpm_dep_dup(const pmdepend_t *dep)
+alpm_depend_t *_alpm_dep_dup(const alpm_depend_t *dep)
{
- pmdepend_t *newdep;
- CALLOC(newdep, 1, sizeof(pmdepend_t), RET_ERR(PM_ERR_MEMORY, NULL));
+ alpm_depend_t *newdep;
+ CALLOC(newdep, 1, sizeof(alpm_depend_t), return NULL);
- STRDUP(newdep->name, dep->name, RET_ERR(PM_ERR_MEMORY, NULL));
+ STRDUP(newdep->name, dep->name, return NULL);
newdep->name_hash = dep->name_hash;
- STRDUP(newdep->version, dep->version, RET_ERR(PM_ERR_MEMORY, NULL));
+ STRDUP(newdep->version, dep->version, return NULL);
newdep->mod = dep->mod;
- return(newdep);
+ return newdep;
}
/* These parameters are messy. We check if this package, given a list of
* targets and a db is safe to remove. We do NOT remove it if it is in the
* target list, or if if the package was explictly installed and
* include_explicit == 0 */
-static int can_remove_package(pmdb_t *db, pmpkg_t *pkg, alpm_list_t *targets,
+static int can_remove_package(alpm_db_t *db, alpm_pkg_t *pkg, alpm_list_t *targets,
int include_explicit)
{
alpm_list_t *i;
if(_alpm_pkg_find(targets, alpm_pkg_get_name(pkg))) {
- return(0);
+ return 0;
}
if(!include_explicit) {
/* see if it was explicitly installed */
- if(alpm_pkg_get_reason(pkg) == PM_PKG_REASON_EXPLICIT) {
- _alpm_log(PM_LOG_DEBUG, "excluding %s -- explicitly installed\n",
+ if(alpm_pkg_get_reason(pkg) == ALPM_PKG_REASON_EXPLICIT) {
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "excluding %s -- explicitly installed\n",
alpm_pkg_get_name(pkg));
- return(0);
+ return 0;
}
}
@@ -497,14 +496,14 @@ static int can_remove_package(pmdb_t *db, pmpkg_t *pkg, alpm_list_t *targets,
/* see if other packages need it */
for(i = _alpm_db_get_pkgcache(db); i; i = i->next) {
- pmpkg_t *lpkg = i->data;
+ alpm_pkg_t *lpkg = i->data;
if(_alpm_dep_edge(lpkg, pkg) && !_alpm_pkg_find(targets, lpkg->name)) {
- return(0);
+ return 0;
}
}
/* it's ok to remove */
- return(1);
+ return 1;
}
/**
@@ -517,23 +516,21 @@ static int can_remove_package(pmdb_t *db, pmpkg_t *pkg, alpm_list_t *targets,
* @param *targs pointer to a list of packages
* @param include_explicit if 0, explicitly installed packages are not included
*/
-void _alpm_recursedeps(pmdb_t *db, alpm_list_t *targs, int include_explicit)
+void _alpm_recursedeps(alpm_db_t *db, alpm_list_t *targs, int include_explicit)
{
alpm_list_t *i, *j;
- ALPM_LOG_FUNC;
-
if(db == NULL || targs == NULL) {
return;
}
for(i = targs; i; i = i->next) {
- pmpkg_t *pkg = i->data;
+ alpm_pkg_t *pkg = i->data;
for(j = _alpm_db_get_pkgcache(db); j; j = j->next) {
- pmpkg_t *deppkg = j->data;
+ alpm_pkg_t *deppkg = j->data;
if(_alpm_dep_edge(pkg, deppkg)
&& can_remove_package(db, deppkg, targs, include_explicit)) {
- _alpm_log(PM_LOG_DEBUG, "adding '%s' to the targets\n",
+ _alpm_log(db->handle, ALPM_LOG_DEBUG, "adding '%s' to the targets\n",
alpm_pkg_get_name(deppkg));
/* add it to the target list */
targs = alpm_list_add(targs, _alpm_pkg_dup(deppkg));
@@ -545,6 +542,7 @@ void _alpm_recursedeps(pmdb_t *db, alpm_list_t *targs, int include_explicit)
/**
* helper function for resolvedeps: search for dep satisfier in dbs
*
+ * @param handle the context handle
* @param dep is the dependency to search for
* @param dbs are the databases to search
* @param excluding are the packages to exclude from the search
@@ -554,8 +552,8 @@ void _alpm_recursedeps(pmdb_t *db, alpm_list_t *targs, int include_explicit)
* an error code without prompting
* @return the resolved package
**/
-static pmpkg_t *resolvedep(pmdepend_t *dep, alpm_list_t *dbs,
- alpm_list_t *excluding, int prompt)
+static alpm_pkg_t *resolvedep(alpm_handle_t *handle, alpm_depend_t *dep,
+ alpm_list_t *dbs, alpm_list_t *excluding, int prompt)
{
alpm_list_t *i, *j;
int ignored = 0;
@@ -565,44 +563,44 @@ static pmpkg_t *resolvedep(pmdepend_t *dep, alpm_list_t *dbs,
/* 1. literals */
for(i = dbs; i; i = i->next) {
- pmpkg_t *pkg = _alpm_db_get_pkgfromcache(i->data, dep->name);
+ alpm_pkg_t *pkg = _alpm_db_get_pkgfromcache(i->data, dep->name);
if(pkg && _alpm_depcmp(pkg, dep) && !_alpm_pkg_find(excluding, pkg->name)) {
- if(_alpm_pkg_should_ignore(pkg)) {
+ if(_alpm_pkg_should_ignore(handle, pkg)) {
int install = 0;
- if (prompt) {
- QUESTION(handle->trans, PM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
+ if(prompt) {
+ QUESTION(handle->trans, ALPM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
NULL, NULL, &install);
} else {
- _alpm_log(PM_LOG_WARNING, _("ignoring package %s-%s\n"), pkg->name, pkg->version);
+ _alpm_log(handle, ALPM_LOG_WARNING, _("ignoring package %s-%s\n"), pkg->name, pkg->version);
}
if(!install) {
ignored = 1;
continue;
}
}
- return(pkg);
+ return pkg;
}
}
/* 2. satisfiers (skip literals here) */
for(i = dbs; i; i = i->next) {
for(j = _alpm_db_get_pkgcache(i->data); j; j = j->next) {
- pmpkg_t *pkg = j->data;
+ alpm_pkg_t *pkg = j->data;
if(_alpm_depcmp(pkg, dep) && strcmp(pkg->name, dep->name) != 0 &&
!_alpm_pkg_find(excluding, pkg->name)) {
- if(_alpm_pkg_should_ignore(pkg)) {
+ if(_alpm_pkg_should_ignore(handle, pkg)) {
int install = 0;
- if (prompt) {
- QUESTION(handle->trans, PM_TRANS_CONV_INSTALL_IGNOREPKG,
+ if(prompt) {
+ QUESTION(handle->trans, ALPM_TRANS_CONV_INSTALL_IGNOREPKG,
pkg, NULL, NULL, &install);
} else {
- _alpm_log(PM_LOG_WARNING, _("ignoring package %s-%s\n"), pkg->name, pkg->version);
+ _alpm_log(handle, ALPM_LOG_WARNING, _("ignoring package %s-%s\n"), pkg->name, pkg->version);
}
if(!install) {
ignored = 1;
continue;
}
}
- _alpm_log(PM_LOG_DEBUG, "provider found (%s provides %s)\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "provider found (%s provides %s)\n",
pkg->name, dep->name);
providers = alpm_list_add(providers, pkg);
/* keep looking for other providers in the all dbs */
@@ -612,66 +610,69 @@ static pmpkg_t *resolvedep(pmdepend_t *dep, alpm_list_t *dbs,
/* first check if one provider is already installed locally */
for(i = providers; i; i = i->next) {
- pmpkg_t *pkg = i->data;
- if (_alpm_pkghash_find(_alpm_db_get_pkgcache_hash(handle->db_local), pkg->name)) {
+ alpm_pkg_t *pkg = i->data;
+ if(_alpm_pkghash_find(_alpm_db_get_pkgcache_hash(handle->db_local), pkg->name)) {
alpm_list_free(providers);
- return(pkg);
+ return pkg;
}
}
count = alpm_list_count(providers);
- if (count >= 1) {
+ if(count >= 1) {
/* default to first provider if there is no QUESTION callback */
int index = 0;
if(count > 1) {
/* if there is more than one provider, we ask the user */
- QUESTION(handle->trans, PM_TRANS_CONV_SELECT_PROVIDER,
+ QUESTION(handle->trans, ALPM_TRANS_CONV_SELECT_PROVIDER,
providers, dep, NULL, &index);
}
if(index >= 0 && index < count) {
- pmpkg_t *pkg = alpm_list_getdata(alpm_list_nth(providers, index));
+ alpm_pkg_t *pkg = alpm_list_getdata(alpm_list_nth(providers, index));
alpm_list_free(providers);
- return(pkg);
+ return pkg;
}
alpm_list_free(providers);
providers = NULL;
}
if(ignored) { /* resolvedeps will override these */
- pm_errno = PM_ERR_PKG_IGNORED;
+ handle->pm_errno = ALPM_ERR_PKG_IGNORED;
} else {
- pm_errno = PM_ERR_PKG_NOT_FOUND;
+ handle->pm_errno = ALPM_ERR_PKG_NOT_FOUND;
}
- return(NULL);
+ return NULL;
}
/** Find a package satisfying a specified dependency.
* First look for a literal, going through each db one by one. Then look for
* providers. The first satisfier found is returned.
* The dependency can include versions with depmod operators.
- * @param dbs an alpm_list_t* of pmdb_t where the satisfier will be searched
+ * @param handle the context handle
+ * @param dbs an alpm_list_t* of alpm_db_t where the satisfier will be searched
* @param depstring package or provision name, versioned or not
- * @return a pmpkg_t* satisfying depstring
+ * @return a alpm_pkg_t* satisfying depstring
*/
-pmpkg_t SYMEXPORT *alpm_find_dbs_satisfier(alpm_list_t *dbs, const char *depstring)
+alpm_pkg_t SYMEXPORT *alpm_find_dbs_satisfier(alpm_handle_t *handle,
+ alpm_list_t *dbs, const char *depstring)
{
- pmdepend_t *dep;
- pmpkg_t *pkg;
+ alpm_depend_t *dep;
+ alpm_pkg_t *pkg;
- ASSERT(dbs, return(NULL));
+ CHECK_HANDLE(handle, return NULL);
+ ASSERT(dbs, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, NULL));
dep = _alpm_splitdep(depstring);
- ASSERT(dep, return(NULL));
- pkg = resolvedep(dep, dbs, NULL, 1);
+ ASSERT(dep, return NULL);
+ pkg = resolvedep(handle, dep, dbs, NULL, 1);
_alpm_dep_free(dep);
- return(pkg);
+ return pkg;
}
/**
* Computes resolvable dependencies for a given package and adds that package
* and those resolvable dependencies to a list.
*
+ * @param handle the context handle
* @param localpkgs is the list of local packages
- * @param dbs_sync are the sync databases
* @param pkg is the package to resolve
* @param packages is a pointer to a list of packages which will be
* searched first for any dependency packages needed to complete the
@@ -686,7 +687,7 @@ pmpkg_t SYMEXPORT *alpm_find_dbs_satisfier(alpm_list_t *dbs, const char *depstri
* unresolvable dependency, in which case the [*packages] list will be
* unmodified by this function
*/
-int _alpm_resolvedeps(alpm_list_t *localpkgs, alpm_list_t *dbs_sync, pmpkg_t *pkg,
+int _alpm_resolvedeps(alpm_handle_t *handle, alpm_list_t *localpkgs, alpm_pkg_t *pkg,
alpm_list_t *preferred, alpm_list_t **packages,
alpm_list_t *remove, alpm_list_t **data)
{
@@ -696,10 +697,8 @@ int _alpm_resolvedeps(alpm_list_t *localpkgs, alpm_list_t *dbs_sync, pmpkg_t *pk
alpm_list_t *deps = NULL;
alpm_list_t *packages_copy;
- ALPM_LOG_FUNC;
-
if(_alpm_pkg_find(*packages, pkg->name) != NULL) {
- return(0);
+ return 0;
}
/* Create a copy of the packages list, so that it can be restored
@@ -709,16 +708,16 @@ int _alpm_resolvedeps(alpm_list_t *localpkgs, alpm_list_t *dbs_sync, pmpkg_t *pk
on that list */
*packages = alpm_list_add(*packages, pkg);
- _alpm_log(PM_LOG_DEBUG, "started resolving dependencies\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "started resolving dependencies\n");
for(i = alpm_list_last(*packages); i; i = i->next) {
- pmpkg_t *tpkg = i->data;
+ alpm_pkg_t *tpkg = i->data;
targ = alpm_list_add(NULL, tpkg);
- deps = alpm_checkdeps(localpkgs, 0, remove, targ);
+ deps = alpm_checkdeps(handle, localpkgs, remove, targ, 0);
alpm_list_free(targ);
for(j = deps; j; j = j->next) {
- pmdepmissing_t *miss = j->data;
- pmdepend_t *missdep = alpm_miss_get_dep(miss);
+ alpm_depmissing_t *miss = j->data;
+ alpm_depend_t *missdep = miss->depend;
/* check if one of the packages in the [*packages] list already satisfies
* this dependency */
if(find_dep_satisfier(*packages, missdep)) {
@@ -727,15 +726,15 @@ int _alpm_resolvedeps(alpm_list_t *localpkgs, alpm_list_t *dbs_sync, pmpkg_t *pk
}
/* check if one of the packages in the [preferred] list already satisfies
* this dependency */
- pmpkg_t *spkg = find_dep_satisfier(preferred, missdep);
+ alpm_pkg_t *spkg = find_dep_satisfier(preferred, missdep);
if(!spkg) {
/* find a satisfier package in the given repositories */
- spkg = resolvedep(missdep, dbs_sync, *packages, 0);
+ spkg = resolvedep(handle, missdep, handle->dbs_sync, *packages, 0);
}
if(!spkg) {
- pm_errno = PM_ERR_UNSATISFIED_DEPS;
+ handle->pm_errno = ALPM_ERR_UNSATISFIED_DEPS;
char *missdepstring = alpm_dep_compute_string(missdep);
- _alpm_log(PM_LOG_WARNING,
+ _alpm_log(handle, ALPM_LOG_WARNING,
_("cannot resolve \"%s\", a dependency of \"%s\"\n"),
missdepstring, tpkg->name);
free(missdepstring);
@@ -744,7 +743,7 @@ int _alpm_resolvedeps(alpm_list_t *localpkgs, alpm_list_t *dbs_sync, pmpkg_t *pk
}
ret = -1;
} else {
- _alpm_log(PM_LOG_DEBUG, "pulling dependency %s (needed by %s)\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "pulling dependency %s (needed by %s)\n",
alpm_pkg_get_name(spkg), alpm_pkg_get_name(tpkg));
*packages = alpm_list_add(*packages, spkg);
_alpm_depmiss_free(miss);
@@ -759,85 +758,22 @@ int _alpm_resolvedeps(alpm_list_t *localpkgs, alpm_list_t *dbs_sync, pmpkg_t *pk
} else {
alpm_list_free(packages_copy);
}
- _alpm_log(PM_LOG_DEBUG, "finished resolving dependencies\n");
- return(ret);
-}
-
-const char SYMEXPORT *alpm_miss_get_target(const pmdepmissing_t *miss)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(miss != NULL, return(NULL));
-
- return(miss->target);
-}
-
-const char SYMEXPORT *alpm_miss_get_causingpkg(const pmdepmissing_t *miss)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(miss != NULL, return(NULL));
-
- return miss->causingpkg;
-}
-
-pmdepend_t SYMEXPORT *alpm_miss_get_dep(pmdepmissing_t *miss)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(miss != NULL, return(NULL));
-
- return(miss->depend);
-}
-
-pmdepmod_t SYMEXPORT alpm_dep_get_mod(const pmdepend_t *dep)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(dep != NULL, return(-1));
-
- return(dep->mod);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "finished resolving dependencies\n");
+ return ret;
}
-const char SYMEXPORT *alpm_dep_get_name(const pmdepend_t *dep)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(dep != NULL, return(NULL));
-
- return(dep->name);
-}
-
-const char SYMEXPORT *alpm_dep_get_version(const pmdepend_t *dep)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(dep != NULL, return(NULL));
-
- return(dep->version);
-}
-
-/** Reverse of splitdep; make a dep string from a pmdepend_t struct.
+/** Reverse of splitdep; make a dep string from a alpm_depend_t struct.
* The string must be freed!
* @param dep the depend to turn into a string
* @return a string-formatted dependency with operator if necessary
*/
-char SYMEXPORT *alpm_dep_compute_string(const pmdepend_t *dep)
+char SYMEXPORT *alpm_dep_compute_string(const alpm_depend_t *dep)
{
const char *name, *opr, *ver;
char *str;
size_t len;
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(dep != NULL, return(NULL));
+ ASSERT(dep != NULL, return NULL);
if(dep->name) {
name = dep->name;
@@ -846,22 +782,22 @@ char SYMEXPORT *alpm_dep_compute_string(const pmdepend_t *dep)
}
switch(dep->mod) {
- case PM_DEP_MOD_ANY:
+ case ALPM_DEP_MOD_ANY:
opr = "";
break;
- case PM_DEP_MOD_GE:
+ case ALPM_DEP_MOD_GE:
opr = ">=";
break;
- case PM_DEP_MOD_LE:
+ case ALPM_DEP_MOD_LE:
opr = "<=";
break;
- case PM_DEP_MOD_EQ:
+ case ALPM_DEP_MOD_EQ:
opr = "=";
break;
- case PM_DEP_MOD_LT:
+ case ALPM_DEP_MOD_LT:
opr = "<";
break;
- case PM_DEP_MOD_GT:
+ case ALPM_DEP_MOD_GT:
opr = ">";
break;
default:
@@ -869,19 +805,19 @@ char SYMEXPORT *alpm_dep_compute_string(const pmdepend_t *dep)
break;
}
- if(dep->mod != PM_DEP_MOD_ANY && dep->version) {
+ if(dep->mod != ALPM_DEP_MOD_ANY && dep->version) {
ver = dep->version;
} else {
ver = "";
}
/* we can always compute len and print the string like this because opr
- * and ver will be empty when PM_DEP_MOD_ANY is the depend type. the
+ * and ver will be empty when ALPM_DEP_MOD_ANY is the depend type. the
* reassignments above also ensure we do not do a strlen(NULL). */
len = strlen(name) + strlen(opr) + strlen(ver) + 1;
- MALLOC(str, len, RET_ERR(PM_ERR_MEMORY, NULL));
+ MALLOC(str, len, return NULL);
snprintf(str, len, "%s%s%s", name, opr, ver);
- return(str);
+ return str;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/deps.h b/lib/libalpm/deps.h
index f728cad0..6ef4cbbe 100644
--- a/lib/libalpm/deps.h
+++ b/lib/libalpm/deps.h
@@ -27,31 +27,16 @@
#include "package.h"
#include "alpm.h"
-/* Dependency */
-struct __pmdepend_t {
- char *name;
- char *version;
- unsigned long name_hash;
- pmdepmod_t mod;
-};
-
-/* Missing dependency */
-struct __pmdepmissing_t {
- char *target;
- pmdepend_t *depend;
- char *causingpkg; /* this is used in case of remove dependency error only */
-};
-
-void _alpm_dep_free(pmdepend_t *dep);
-pmdepend_t *_alpm_dep_dup(const pmdepend_t *dep);
-void _alpm_depmiss_free(pmdepmissing_t *miss);
-alpm_list_t *_alpm_sortbydeps(alpm_list_t *targets, int reverse);
-void _alpm_recursedeps(pmdb_t *db, alpm_list_t *targs, int include_explicit);
-int _alpm_resolvedeps(alpm_list_t *localpkgs, alpm_list_t *dbs_sync, pmpkg_t *pkg,
+void _alpm_dep_free(alpm_depend_t *dep);
+alpm_depend_t *_alpm_dep_dup(const alpm_depend_t *dep);
+void _alpm_depmiss_free(alpm_depmissing_t *miss);
+alpm_list_t *_alpm_sortbydeps(alpm_handle_t *handle, alpm_list_t *targets, int reverse);
+void _alpm_recursedeps(alpm_db_t *db, alpm_list_t *targs, int include_explicit);
+int _alpm_resolvedeps(alpm_handle_t *handle, alpm_list_t *localpkgs, alpm_pkg_t *pkg,
alpm_list_t *preferred, alpm_list_t **packages, alpm_list_t *remove,
alpm_list_t **data);
-pmdepend_t *_alpm_splitdep(const char *depstring);
-int _alpm_depcmp(pmpkg_t *pkg, pmdepend_t *dep);
+alpm_depend_t *_alpm_splitdep(const char *depstring);
+int _alpm_depcmp(alpm_pkg_t *pkg, alpm_depend_t *dep);
#endif /* _ALPM_DEPS_H */
diff --git a/lib/libalpm/diskspace.c b/lib/libalpm/diskspace.c
index 066107d7..b28b88ab 100644
--- a/lib/libalpm/diskspace.c
+++ b/lib/libalpm/diskspace.c
@@ -39,10 +39,6 @@
#include <sys/types.h>
#endif
-/* libarchive */
-#include <archive.h>
-#include <archive_entry.h>
-
/* libalpm */
#include "diskspace.h"
#include "alpm_list.h"
@@ -56,10 +52,10 @@ static int mount_point_cmp(const void *p1, const void *p2)
const alpm_mountpoint_t *mp1 = p1;
const alpm_mountpoint_t *mp2 = p2;
/* the negation will sort all mountpoints before their parent */
- return(-strcmp(mp1->mount_dir, mp2->mount_dir));
+ return -strcmp(mp1->mount_dir, mp2->mount_dir);
}
-static alpm_list_t *mount_point_list(void)
+static alpm_list_t *mount_point_list(alpm_handle_t *handle)
{
alpm_list_t *mount_points = NULL, *ptr;
alpm_mountpoint_t *mp;
@@ -71,23 +67,23 @@ static alpm_list_t *mount_point_list(void)
fp = setmntent(MOUNTED, "r");
- if (fp == NULL) {
- return(NULL);
+ if(fp == NULL) {
+ return NULL;
}
while((mnt = getmntent(fp))) {
if(!mnt) {
- _alpm_log(PM_LOG_WARNING, _("could not get filesystem information\n"));
+ _alpm_log(handle, ALPM_LOG_WARNING, _("could not get filesystem information\n"));
continue;
}
if(statvfs(mnt->mnt_dir, &fsp) != 0) {
- _alpm_log(PM_LOG_WARNING,
+ _alpm_log(handle, ALPM_LOG_WARNING,
_("could not get filesystem information for %s: %s\n"),
mnt->mnt_dir, strerror(errno));
continue;
}
- CALLOC(mp, 1, sizeof(alpm_mountpoint_t), RET_ERR(PM_ERR_MEMORY, NULL));
+ CALLOC(mp, 1, sizeof(alpm_mountpoint_t), RET_ERR(handle, ALPM_ERR_MEMORY, NULL));
mp->mount_dir = strdup(mnt->mnt_dir);
mp->mount_dir_len = strlen(mp->mount_dir);
memcpy(&(mp->fsp), &fsp, sizeof(struct statvfs));
@@ -103,12 +99,12 @@ static alpm_list_t *mount_point_list(void)
entries = getmntinfo(&fsp, MNT_NOWAIT);
- if (entries < 0) {
- return(NULL);
+ if(entries < 0) {
+ return NULL;
}
for(; entries-- > 0; fsp++) {
- CALLOC(mp, 1, sizeof(alpm_mountpoint_t), RET_ERR(PM_ERR_MEMORY, NULL));
+ CALLOC(mp, 1, sizeof(alpm_mountpoint_t), RET_ERR(ALPM_ERR_MEMORY, NULL));
mp->mount_dir = strdup(fsp->f_mntonname);
mp->mount_dir_len = strlen(mp->mount_dir);
memcpy(&(mp->fsp), fsp, sizeof(FSSTATSTYPE));
@@ -126,9 +122,9 @@ static alpm_list_t *mount_point_list(void)
mount_point_cmp);
for(ptr = mount_points; ptr != NULL; ptr = ptr->next) {
mp = ptr->data;
- _alpm_log(PM_LOG_DEBUG, "mountpoint: %s\n", mp->mount_dir);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "mountpoint: %s\n", mp->mount_dir);
}
- return(mount_points);
+ return mount_points;
}
static alpm_mountpoint_t *match_mount_point(const alpm_list_t *mount_points,
@@ -140,25 +136,30 @@ static alpm_mountpoint_t *match_mount_point(const alpm_list_t *mount_points,
alpm_mountpoint_t *data = mp->data;
if(strncmp(data->mount_dir, real_path, data->mount_dir_len) == 0) {
- return(data);
+ return data;
}
}
/* should not get here... */
- return(NULL);
+ return NULL;
}
-static int calculate_removed_size(const alpm_list_t *mount_points,
- pmpkg_t *pkg)
+static int calculate_removed_size(alpm_handle_t *handle,
+ const alpm_list_t *mount_points, alpm_pkg_t *pkg)
{
- alpm_list_t *file;
+ size_t i;
+ alpm_filelist_t *filelist = alpm_pkg_get_files(pkg);
+
+ if(!filelist->count) {
+ return 0;
+ }
- alpm_list_t *files = alpm_pkg_get_files(pkg);
- for(file = files; file; file = file->next) {
+ for(i = 0; i < filelist->count; i++) {
+ const alpm_file_t *file = filelist->files + i;
alpm_mountpoint_t *mp;
struct stat st;
char path[PATH_MAX];
- const char *filename = file->data;
+ const char *filename = file->name;
snprintf(path, PATH_MAX, "%s%s", handle->root, filename);
_alpm_lstat(path, &st);
@@ -171,7 +172,7 @@ static int calculate_removed_size(const alpm_list_t *mount_points,
mp = match_mount_point(mount_points, path);
if(mp == NULL) {
- _alpm_log(PM_LOG_WARNING,
+ _alpm_log(handle, ALPM_LOG_WARNING,
_("could not determine mount point for file %s\n"), filename);
continue;
}
@@ -182,129 +183,104 @@ static int calculate_removed_size(const alpm_list_t *mount_points,
mp->used |= USED_REMOVE;
}
- return(0);
+ return 0;
}
-static int calculate_installed_size(const alpm_list_t *mount_points,
- pmpkg_t *pkg)
+static int calculate_installed_size(alpm_handle_t *handle,
+ const alpm_list_t *mount_points, alpm_pkg_t *pkg)
{
- int ret=0;
- struct archive *archive;
- struct archive_entry *entry;
-
- if ((archive = archive_read_new()) == NULL) {
- pm_errno = PM_ERR_LIBARCHIVE;
- ret = -1;
- goto cleanup;
- }
-
- archive_read_support_compression_all(archive);
- archive_read_support_format_all(archive);
+ size_t i;
+ alpm_filelist_t *filelist = alpm_pkg_get_files(pkg);
- if(archive_read_open_filename(archive, pkg->origin_data.file,
- ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
- pm_errno = PM_ERR_PKG_OPEN;
- ret = -1;
- goto cleanup;
+ if(!filelist->count) {
+ return 0;
}
- while(archive_read_next_header(archive, &entry) == ARCHIVE_OK) {
+ for(i = 0; i < filelist->count; i++) {
+ const alpm_file_t *file = filelist->files + i;
alpm_mountpoint_t *mp;
- const char *filename;
- mode_t mode;
char path[PATH_MAX];
-
- filename = archive_entry_pathname(entry);
- mode = archive_entry_mode(entry);
+ const char *filename = file->name;
/* libarchive reports these as zero size anyways */
/* NOTE: if we do start accounting for directory size, a dir matching a
* mountpoint needs to be attributed to the parent, not the mountpoint. */
- if(S_ISDIR(mode) || S_ISLNK(mode)) {
+ if(S_ISDIR(file->mode) || S_ISLNK(file->mode)) {
continue;
}
/* approximate space requirements for db entries */
if(filename[0] == '.') {
- filename = alpm_option_get_dbpath();
+ filename = alpm_option_get_dbpath(handle);
}
snprintf(path, PATH_MAX, "%s%s", handle->root, filename);
mp = match_mount_point(mount_points, path);
if(mp == NULL) {
- _alpm_log(PM_LOG_WARNING,
+ _alpm_log(handle, ALPM_LOG_WARNING,
_("could not determine mount point for file %s\n"), filename);
continue;
}
/* the addition of (divisor - 1) performs ceil() with integer division */
mp->blocks_needed +=
- (archive_entry_size(entry) + mp->fsp.f_bsize - 1l) / mp->fsp.f_bsize;
+ (file->size + mp->fsp.f_bsize - 1l) / mp->fsp.f_bsize;
mp->used |= USED_INSTALL;
-
- if(archive_read_data_skip(archive)) {
- _alpm_log(PM_LOG_ERROR, _("error while reading package %s: %s\n"),
- pkg->name, archive_error_string(archive));
- pm_errno = PM_ERR_LIBARCHIVE;
- break;
- }
}
- archive_read_finish(archive);
-
-cleanup:
- return(ret);
+ return 0;
}
-int _alpm_check_diskspace(pmtrans_t *trans, pmdb_t *db_local)
+int _alpm_check_diskspace(alpm_handle_t *handle)
{
alpm_list_t *mount_points, *i;
alpm_mountpoint_t *root_mp;
size_t replaces = 0, current = 0, numtargs;
- int abort = 0;
+ int error = 0;
alpm_list_t *targ;
+ alpm_trans_t *trans = handle->trans;
numtargs = alpm_list_count(trans->add);
- mount_points = mount_point_list();
+ mount_points = mount_point_list(handle);
if(mount_points == NULL) {
- _alpm_log(PM_LOG_ERROR, _("could not determine filesystem mount points\n"));
- return(-1);
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not determine filesystem mount points\n"));
+ return -1;
}
root_mp = match_mount_point(mount_points, handle->root);
if(root_mp == NULL) {
- _alpm_log(PM_LOG_ERROR, _("could not determine root mount point %s\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not determine root mount point %s\n"),
handle->root);
- return(-1);
+ return -1;
}
replaces = alpm_list_count(trans->remove);
if(replaces) {
numtargs += replaces;
for(targ = trans->remove; targ; targ = targ->next, current++) {
- pmpkg_t *local_pkg;
+ alpm_pkg_t *local_pkg;
int percent = (current * 100) / numtargs;
- PROGRESS(trans, PM_TRANS_PROGRESS_DISKSPACE_START, "", percent,
+ PROGRESS(trans, ALPM_TRANS_PROGRESS_DISKSPACE_START, "", percent,
numtargs, current);
local_pkg = targ->data;
- calculate_removed_size(mount_points, local_pkg);
+ calculate_removed_size(handle, mount_points, local_pkg);
}
}
for(targ = trans->add; targ; targ = targ->next, current++) {
- pmpkg_t *pkg, *local_pkg;
+ alpm_pkg_t *pkg, *local_pkg;
int percent = (current * 100) / numtargs;
- PROGRESS(trans, PM_TRANS_PROGRESS_DISKSPACE_START, "", percent,
+ PROGRESS(trans, ALPM_TRANS_PROGRESS_DISKSPACE_START, "", percent,
numtargs, current);
pkg = targ->data;
/* is this package already installed? */
- local_pkg = _alpm_db_get_pkgfromcache(db_local, pkg->name);
+ local_pkg = _alpm_db_get_pkgfromcache(handle->db_local, pkg->name);
if(local_pkg) {
- calculate_removed_size(mount_points, local_pkg);
+ calculate_removed_size(handle, mount_points, local_pkg);
}
- calculate_installed_size(mount_points, pkg);
+ calculate_installed_size(handle, mount_points, pkg);
for(i = mount_points; i; i = alpm_list_next(i)) {
alpm_mountpoint_t *data = i->data;
@@ -314,30 +290,30 @@ int _alpm_check_diskspace(pmtrans_t *trans, pmdb_t *db_local)
}
}
- PROGRESS(trans, PM_TRANS_PROGRESS_DISKSPACE_START, "", 100,
+ PROGRESS(trans, ALPM_TRANS_PROGRESS_DISKSPACE_START, "", 100,
numtargs, current);
for(i = mount_points; i; i = alpm_list_next(i)) {
alpm_mountpoint_t *data = i->data;
if(data->used && data->read_only) {
- _alpm_log(PM_LOG_ERROR, _("Partition %s is mounted read only\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("Partition %s is mounted read only\n"),
data->mount_dir);
- abort = 1;
+ error = 1;
} else if(data->used & USED_INSTALL) {
/* cushion is roughly min(5% capacity, 20MiB) */
long fivepc = ((long)data->fsp.f_blocks / 20) + 1;
long twentymb = (20 * 1024 * 1024 / (long)data->fsp.f_bsize) + 1;
long cushion = fivepc < twentymb ? fivepc : twentymb;
- _alpm_log(PM_LOG_DEBUG, "partition %s, needed %ld, cushion %ld, free %ld\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "partition %s, needed %ld, cushion %ld, free %ld\n",
data->mount_dir, data->max_blocks_needed, cushion,
(unsigned long)data->fsp.f_bfree);
if(data->max_blocks_needed + cushion >= 0 &&
(unsigned long)(data->max_blocks_needed + cushion) > data->fsp.f_bfree) {
- _alpm_log(PM_LOG_ERROR, _("Partition %s too full: %ld blocks needed, %ld blocks free\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("Partition %s too full: %ld blocks needed, %ld blocks free\n"),
data->mount_dir, data->max_blocks_needed + cushion,
(unsigned long)data->fsp.f_bfree);
- abort = 1;
+ error = 1;
}
}
}
@@ -348,11 +324,11 @@ int _alpm_check_diskspace(pmtrans_t *trans, pmdb_t *db_local)
}
FREELIST(mount_points);
- if(abort) {
- RET_ERR(PM_ERR_DISK_SPACE, -1);
+ if(error) {
+ RET_ERR(handle, ALPM_ERR_DISK_SPACE, -1);
}
- return(0);
+ return 0;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/diskspace.h b/lib/libalpm/diskspace.h
index 2894a0c2..79e16772 100644
--- a/lib/libalpm/diskspace.h
+++ b/lib/libalpm/diskspace.h
@@ -46,7 +46,7 @@ typedef struct __alpm_mountpoint_t {
FSSTATSTYPE fsp;
} alpm_mountpoint_t;
-int _alpm_check_diskspace(pmtrans_t *trans, pmdb_t *db_local);
+int _alpm_check_diskspace(alpm_handle_t *handle);
#endif /* _ALPM_DISKSPACE_H */
diff --git a/lib/libalpm/dload.c b/lib/libalpm/dload.c
index e3d30f23..dc4f91e5 100644
--- a/lib/libalpm/dload.c
+++ b/lib/libalpm/dload.c
@@ -29,14 +29,9 @@
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
-/* the following two are needed for FreeBSD's libfetch */
-#include <limits.h> /* PATH_MAX */
-#if defined(HAVE_SYS_PARAM_H)
-#include <sys/param.h> /* MAXHOSTNAMELEN */
-#endif
-#ifdef HAVE_LIBFETCH
-#include <fetch.h>
+#ifdef HAVE_LIBCURL
+#include <curl/curl.h>
#endif
/* libalpm */
@@ -47,112 +42,244 @@
#include "util.h"
#include "handle.h"
-static char *get_filename(const char *url) {
+static const char *get_filename(const char *url)
+{
char *filename = strrchr(url, '/');
if(filename != NULL) {
filename++;
}
- return(filename);
+ return filename;
}
-#ifdef HAVE_LIBFETCH
-static char *get_destfile(const char *path, const char *filename) {
- char *destfile;
- /* len = localpath len + filename len + null */
- size_t len = strlen(path) + strlen(filename) + 1;
- CALLOC(destfile, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, NULL));
- snprintf(destfile, len, "%s%s", path, filename);
+#ifdef HAVE_LIBCURL
+static double prevprogress; /* last download amount */
- return(destfile);
+static char *get_fullpath(const char *path, const char *filename,
+ const char *suffix)
+{
+ char *filepath;
+ /* len = localpath len + filename len + suffix len + null */
+ size_t len = strlen(path) + strlen(filename) + strlen(suffix) + 1;
+ CALLOC(filepath, len, sizeof(char), return NULL);
+ snprintf(filepath, len, "%s%s%s", path, filename, suffix);
+
+ return filepath;
}
-static char *get_tempfile(const char *path, const char *filename) {
- char *tempfile;
- /* len = localpath len + filename len + '.part' len + null */
- size_t len = strlen(path) + strlen(filename) + 6;
- CALLOC(tempfile, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, NULL));
- snprintf(tempfile, len, "%s%s.part", path, filename);
+#define check_stop() if(dload_interrupted) { ret = -1; goto cleanup; }
+enum sighandlers { OLD = 0, NEW = 1 };
- return(tempfile);
+static int dload_interrupted;
+static void inthandler(int UNUSED signum)
+{
+ dload_interrupted = 1;
}
-static const char *gethost(struct url *fileurl)
+static int curl_progress(void *file, double dltotal, double dlnow,
+ double UNUSED ultotal, double UNUSED ulnow)
{
- const char *host = _("disk");
- if(strcmp(SCHEME_FILE, fileurl->scheme) != 0) {
- host = fileurl->host;
+ struct dload_payload *payload = (struct dload_payload *)file;
+ double current_size, total_size;
+
+ /* SIGINT sent, abort by alerting curl */
+ if(dload_interrupted) {
+ return 1;
+ }
+
+ /* none of what follows matters if the front end has no callback */
+ if(payload->handle->dlcb == NULL) {
+ return 0;
+ }
+
+ current_size = payload->initial_size + dlnow;
+ total_size = payload->initial_size + dltotal;
+
+ if(DOUBLE_EQ(dltotal, 0) || DOUBLE_EQ(prevprogress, total_size)) {
+ return 0;
+ }
+
+ /* initialize the progress bar here to avoid displaying it when
+ * a repo is up to date and nothing gets downloaded */
+ if(DOUBLE_EQ(prevprogress, 0)) {
+ payload->handle->dlcb(payload->filename, 0, (long)dltotal);
}
- return(host);
+
+ payload->handle->dlcb(payload->filename, (long)current_size, (long)total_size);
+
+ prevprogress = current_size;
+
+ return 0;
}
-int dload_interrupted;
-static void inthandler(int signum)
+static int curl_gethost(const char *url, char *buffer)
{
- dload_interrupted = 1;
+ size_t hostlen;
+ char *p;
+
+ if(strncmp(url, "file://", 7) == 0) {
+ strcpy(buffer, _("disk"));
+ } else {
+ p = strstr(url, "//");
+ if(!p) {
+ return 1;
+ }
+ p += 2; /* jump over the found // */
+ hostlen = strcspn(p, "/");
+ if(hostlen > 255) {
+ /* buffer overflow imminent */
+ return 1;
+ }
+ snprintf(buffer, hostlen + 1, "%s", p);
+ }
+
+ return 0;
}
-#define check_stop() if(dload_interrupted) { ret = -1; goto cleanup; }
-enum sighandlers { OLD = 0, NEW = 1 };
+static int utimes_long(const char *path, long seconds)
+{
+ if(seconds != -1) {
+ struct timeval tv[2];
+ memset(&tv, 0, sizeof(tv));
+ tv[0].tv_sec = tv[1].tv_sec = seconds;
+ return utimes(path, tv);
+ }
+ return 0;
+}
+
+static size_t parse_headers(void *ptr, size_t size, size_t nmemb, void *user)
+{
+ size_t realsize = size * nmemb;
+ const char *fptr, *endptr = NULL;
+ const char * const cd_header = "Content-Disposition:";
+ const char * const fn_key = "filename=";
+ struct dload_payload *payload = (struct dload_payload *)user;
+
+ if(_alpm_raw_ncmp(cd_header, ptr, strlen(cd_header)) == 0) {
+ if((fptr = strstr(ptr, fn_key))) {
+ fptr += strlen(fn_key);
+
+ /* find the end of the field, which is either a semi-colon, or the end of
+ * the data. As per curl_easy_setopt(3), we cannot count on headers being
+ * null terminated, so we look for the closing \r\n */
+ endptr = fptr + strcspn(fptr, ";\r\n") - 1;
+
+ /* remove quotes */
+ if(*fptr == '"' && *endptr == '"') {
+ fptr++;
+ endptr--;
+ }
+
+ STRNDUP(payload->cd_filename, fptr, endptr - fptr + 1,
+ RET_ERR(payload->handle, ALPM_ERR_MEMORY, realsize));
+ }
+ }
-static int download_internal(const char *url, const char *localpath,
- int force) {
+ return realsize;
+}
+
+static int curl_download_internal(struct dload_payload *payload,
+ const char *localpath, char **final_file)
+{
+ int ret = -1, should_unlink = 0;
FILE *localf = NULL;
+ const char *useragent;
+ const char *open_mode = "wb";
+ char *destfile = NULL, *tempfile = NULL, *effective_url;
+ /* RFC1123 states applications should support this length */
+ char hostname[256];
+ char error_buffer[CURL_ERROR_SIZE];
struct stat st;
- int ret = 0;
- off_t dl_thisfile = 0;
- ssize_t nread = 0;
- char *tempfile, *destfile, *filename;
+ long timecond, remote_time = -1;
+ double remote_size, bytes_dl;
struct sigaction sig_pipe[2], sig_int[2];
+ /* shortcut to our handle within the payload */
+ alpm_handle_t *handle = payload->handle;
- off_t local_size = 0;
- time_t local_time = 0;
-
- struct url *fileurl;
- struct url_stat ust;
- fetchIO *dlf = NULL;
-
- char buffer[PM_DLBUF_LEN];
+ if(!payload->filename) {
+ payload->filename = get_filename(payload->fileurl);
+ }
+ if(!payload->filename || curl_gethost(payload->fileurl, hostname) != 0) {
+ _alpm_log(handle, ALPM_LOG_ERROR, _("url '%s' is invalid\n"), payload->fileurl);
+ RET_ERR(handle, ALPM_ERR_SERVER_BAD_URL, -1);
+ }
- filename = get_filename(url);
- if(!filename) {
- _alpm_log(PM_LOG_ERROR, _("url '%s' is invalid\n"), url);
- RET_ERR(PM_ERR_SERVER_BAD_URL, -1);
+ if(strlen(payload->filename) > 0 && strcmp(payload->filename, ".sig") != 0) {
+ destfile = get_fullpath(localpath, payload->filename, "");
+ tempfile = get_fullpath(localpath, payload->filename, ".part");
+ if(!destfile || !tempfile) {
+ goto cleanup;
+ }
+ } else {
+ /* URL isn't to a file and ended with a slash */
+ int fd;
+ char randpath[PATH_MAX];
+
+ /* we can't support resuming this kind of download, so a partial transfer
+ * will be destroyed */
+ should_unlink = 1;
+
+ /* create a random filename, which is opened with O_EXCL */
+ snprintf(randpath, PATH_MAX, "%salpmtmp.XXXXXX", localpath);
+ if((fd = mkstemp(randpath)) == -1 || !(localf = fdopen(fd, open_mode))) {
+ unlink(randpath);
+ close(fd);
+ _alpm_log(handle, ALPM_LOG_ERROR,
+ _("failed to create temporary file for download\n"));
+ goto cleanup;
+ }
+ /* localf now points to our alpmtmp.XXXXXX */
+ STRDUP(tempfile, randpath, RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+ payload->filename = strrchr(randpath, '/') + 1;
}
- fileurl = fetchParseURL(url);
- if(!fileurl) {
- _alpm_log(PM_LOG_ERROR, _("url '%s' is invalid\n"), url);
- RET_ERR(PM_ERR_LIBFETCH, -1);
+ error_buffer[0] = '\0';
+
+ /* the curl_easy handle is initialized with the alpm handle, so we only need
+ * to reset the curl handle set parameters for each time it's used. */
+ curl_easy_reset(handle->curl);
+ curl_easy_setopt(handle->curl, CURLOPT_URL, payload->fileurl);
+ curl_easy_setopt(handle->curl, CURLOPT_FAILONERROR, 1L);
+ curl_easy_setopt(handle->curl, CURLOPT_ERRORBUFFER, error_buffer);
+ curl_easy_setopt(handle->curl, CURLOPT_CONNECTTIMEOUT, 10L);
+ curl_easy_setopt(handle->curl, CURLOPT_FILETIME, 1L);
+ curl_easy_setopt(handle->curl, CURLOPT_NOPROGRESS, 0L);
+ curl_easy_setopt(handle->curl, CURLOPT_FOLLOWLOCATION, 1L);
+ curl_easy_setopt(handle->curl, CURLOPT_PROGRESSFUNCTION, curl_progress);
+ curl_easy_setopt(handle->curl, CURLOPT_PROGRESSDATA, (void *)payload);
+ curl_easy_setopt(handle->curl, CURLOPT_LOW_SPEED_LIMIT, 1024L);
+ curl_easy_setopt(handle->curl, CURLOPT_LOW_SPEED_TIME, 10L);
+ curl_easy_setopt(handle->curl, CURLOPT_HEADERFUNCTION, parse_headers);
+ curl_easy_setopt(handle->curl, CURLOPT_WRITEHEADER, (void *)payload);
+
+ if(payload->max_size) {
+ curl_easy_setopt(handle->curl, CURLOPT_MAXFILESIZE, payload->max_size);
}
- destfile = get_destfile(localpath, filename);
- tempfile = get_tempfile(localpath, filename);
-
- if(stat(tempfile, &st) == 0 && S_ISREG(st.st_mode) && st.st_size > 0) {
- _alpm_log(PM_LOG_DEBUG, "tempfile found, attempting continuation\n");
- local_time = fileurl->last_modified = st.st_mtime;
- local_size = fileurl->offset = (off_t)st.st_size;
- dl_thisfile = st.st_size;
- localf = fopen(tempfile, "ab");
- } else if(!force && stat(destfile, &st) == 0 && S_ISREG(st.st_mode) && st.st_size > 0) {
- _alpm_log(PM_LOG_DEBUG, "destfile found, using mtime only\n");
- local_time = fileurl->last_modified = st.st_mtime;
- local_size = /* no fu->off here */ (off_t)st.st_size;
- } else {
- _alpm_log(PM_LOG_DEBUG, "no file found matching criteria, starting from scratch\n");
+ useragent = getenv("HTTP_USER_AGENT");
+ if(useragent != NULL) {
+ curl_easy_setopt(handle->curl, CURLOPT_USERAGENT, useragent);
}
- /* pass the raw filename for passing to the callback function */
- _alpm_log(PM_LOG_DEBUG, "using '%s' for download progress\n", filename);
+ if(!payload->allow_resume && !payload->force && stat(destfile, &st) == 0) {
+ /* start from scratch, but only download if our local is out of date. */
+ curl_easy_setopt(handle->curl, CURLOPT_TIMECONDITION, CURL_TIMECOND_IFMODSINCE);
+ curl_easy_setopt(handle->curl, CURLOPT_TIMEVALUE, (long)st.st_mtime);
+ } else if(stat(tempfile, &st) == 0 && payload->allow_resume) {
+ /* a previous partial download exists, resume from end of file. */
+ open_mode = "ab";
+ curl_easy_setopt(handle->curl, CURLOPT_RESUME_FROM, (long)st.st_size);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "tempfile found, attempting continuation\n");
+ payload->initial_size = (double)st.st_size;
+ }
- /* print proxy info for debug purposes */
- _alpm_log(PM_LOG_DEBUG, "HTTP_PROXY: %s\n", getenv("HTTP_PROXY"));
- _alpm_log(PM_LOG_DEBUG, "http_proxy: %s\n", getenv("http_proxy"));
- _alpm_log(PM_LOG_DEBUG, "FTP_PROXY: %s\n", getenv("FTP_PROXY"));
- _alpm_log(PM_LOG_DEBUG, "ftp_proxy: %s\n", getenv("ftp_proxy"));
+ if(localf == NULL) {
+ localf = fopen(tempfile, open_mode);
+ if(localf == NULL) {
+ goto cleanup;
+ }
+ }
- /* 10s timeout */
- fetchTimeout = 10;
+ curl_easy_setopt(handle->curl, CURLOPT_WRITEDATA, localf);
/* ignore any SIGPIPE signals- these may occur if our FTP socket dies or
* something along those lines. Store the old signal handler first. */
@@ -169,169 +296,98 @@ static int download_internal(const char *url, const char *localpath,
sigaction(SIGINT, NULL, &sig_int[OLD]);
sigaction(SIGINT, &sig_int[NEW], NULL);
- /* NOTE: libfetch does not reset the error code, be sure to do it before
- * calls into the library */
-
- /* TODO: if we call fetchStat() and get a redirect (disabling automagic
- * redirect following), we should repeat the file locator stuff and get a new
- * filename rather than only base if off the first URL, and then verify
- * get_filename() didn't return ''. Of course, libfetch might not even allow
- * us to even get that URL...FS#22645. This would allow us to download things
- * without totally puking like
- * http://www.archlinux.org/packages/community/x86_64/exim/download/ */
-
- /* find out the remote size *and* mtime in one go. there is a lot of
- * trouble in trying to do both size and "if-modified-since" logic in a
- * non-stat request, so avoid it. */
- fetchLastErrCode = 0;
- if(fetchStat(fileurl, &ust, "") == -1) {
- pm_errno = PM_ERR_LIBFETCH;
- _alpm_log(PM_LOG_ERROR, _("failed retrieving file '%s' from %s : %s\n"),
- filename, gethost(fileurl), fetchLastErrString);
- ret = -1;
+ /* Progress 0 - initialize */
+ prevprogress = 0;
+
+ /* perform transfer */
+ handle->curlerr = curl_easy_perform(handle->curl);
+
+ /* was it a success? */
+ if(handle->curlerr == CURLE_ABORTED_BY_CALLBACK) {
goto cleanup;
- }
- check_stop();
-
- _alpm_log(PM_LOG_DEBUG, "ust.mtime: %ld local_time: %ld compare: %ld\n",
- ust.mtime, local_time, local_time - ust.mtime);
- _alpm_log(PM_LOG_DEBUG, "ust.size: %jd local_size: %jd compare: %jd\n",
- (intmax_t)ust.size, (intmax_t)local_size, (intmax_t)(local_size - ust.size));
- if(!force && ust.mtime && ust.mtime == local_time
- && ust.size && ust.size == local_size) {
- /* the remote time and size values agreed with what we have, so move on
- * because there is nothing more to do. */
- _alpm_log(PM_LOG_DEBUG, "files are identical, skipping %s\n", filename);
- ret = 1;
+ } else if(handle->curlerr != CURLE_OK) {
+ if(!payload->errors_ok) {
+ handle->pm_errno = ALPM_ERR_LIBCURL;
+ _alpm_log(handle, ALPM_LOG_ERROR, _("failed retrieving file '%s' from %s : %s\n"),
+ payload->filename, hostname, error_buffer);
+ } else {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "failed retrieving file '%s' from %s : %s\n",
+ payload->filename, hostname, error_buffer);
+ }
+ unlink(tempfile);
goto cleanup;
}
- if(!ust.mtime || ust.mtime != local_time) {
- _alpm_log(PM_LOG_DEBUG, "mtimes were different or unavailable, downloading %s from beginning\n", filename);
- fileurl->offset = 0;
- }
- fetchLastErrCode = 0;
- dlf = fetchGet(fileurl, "");
- check_stop();
+ /* retrieve info about the state of the transfer */
+ curl_easy_getinfo(handle->curl, CURLINFO_FILETIME, &remote_time);
+ curl_easy_getinfo(handle->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &remote_size);
+ curl_easy_getinfo(handle->curl, CURLINFO_SIZE_DOWNLOAD, &bytes_dl);
+ curl_easy_getinfo(handle->curl, CURLINFO_CONDITION_UNMET, &timecond);
+ curl_easy_getinfo(handle->curl, CURLINFO_EFFECTIVE_URL, &effective_url);
- if(fetchLastErrCode != 0 || dlf == NULL) {
- pm_errno = PM_ERR_LIBFETCH;
- _alpm_log(PM_LOG_ERROR, _("failed retrieving file '%s' from %s : %s\n"),
- filename, gethost(fileurl), fetchLastErrString);
- ret = -1;
+ /* time condition was met and we didn't download anything. we need to
+ * clean up the 0 byte .part file that's left behind. */
+ if(timecond == 1 && DOUBLE_EQ(bytes_dl, 0)) {
+ ret = 1;
+ unlink(tempfile);
goto cleanup;
- } else {
- _alpm_log(PM_LOG_DEBUG, "connected to %s successfully\n", fileurl->host);
}
- if(localf && fileurl->offset == 0) {
- _alpm_log(PM_LOG_WARNING, _("resuming download of %s not possible; starting over\n"), filename);
- fclose(localf);
- localf = NULL;
- } else if(fileurl->offset) {
- _alpm_log(PM_LOG_DEBUG, "resuming download at position %jd\n", (intmax_t)fileurl->offset);
+ /* remote_size isn't necessarily the full size of the file, just what the
+ * server reported as remaining to download. compare it to what curl reported
+ * as actually being transferred during curl_easy_perform() */
+ if(!DOUBLE_EQ(remote_size, -1) && !DOUBLE_EQ(bytes_dl, -1) &&
+ !DOUBLE_EQ(bytes_dl, remote_size)) {
+ handle->pm_errno = ALPM_ERR_RETRIEVE;
+ _alpm_log(handle, ALPM_LOG_ERROR, _("%s appears to be truncated: %jd/%jd bytes\n"),
+ payload->filename, (intmax_t)bytes_dl, (intmax_t)remote_size);
+ goto cleanup;
}
-
- if(localf == NULL) {
- _alpm_rmrf(tempfile);
- fileurl->offset = (off_t)0;
- dl_thisfile = 0;
- localf = fopen(tempfile, "wb");
- if(localf == NULL) { /* still null? */
- pm_errno = PM_ERR_RETRIEVE;
- _alpm_log(PM_LOG_ERROR, _("error writing to file '%s': %s\n"),
- tempfile, strerror(errno));
- ret = -1;
- goto cleanup;
+ if(payload->cd_filename) {
+ /* content-disposition header has a better name for our file */
+ free(destfile);
+ destfile = get_fullpath(localpath, payload->cd_filename, "");
+ } else {
+ const char *effective_filename = strrchr(effective_url, '/');
+ if(effective_filename) {
+ effective_filename++;
+
+ /* if destfile was never set, we wrote to a tempfile. even if destfile is
+ * set, we may have followed some redirects and the effective url may
+ * have a better suggestion as to what to name our file. in either case,
+ * refactor destfile to this newly derived name. */
+ if(!destfile || strcmp(effective_filename, strrchr(destfile, '/') + 1) != 0) {
+ free(destfile);
+ destfile = get_fullpath(localpath, effective_filename, "");
+ }
}
}
- /* Progress 0 - initialize */
- if(handle->dlcb) {
- handle->dlcb(filename, 0, ust.size);
+ ret = 0;
+
+cleanup:
+ if(localf != NULL) {
+ fclose(localf);
+ utimes_long(tempfile, remote_time);
}
- while((nread = fetchIO_read(dlf, buffer, PM_DLBUF_LEN)) > 0) {
- check_stop();
- size_t nwritten = 0;
- nwritten = fwrite(buffer, 1, (size_t)nread, localf);
- if((nwritten != (size_t)nread) || ferror(localf)) {
- pm_errno = PM_ERR_RETRIEVE;
- _alpm_log(PM_LOG_ERROR, _("error writing to file '%s': %s\n"),
- tempfile, strerror(errno));
+ if(ret == 0) {
+ if(rename(tempfile, destfile)) {
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
+ tempfile, destfile, strerror(errno));
ret = -1;
- goto cleanup;
- }
- dl_thisfile += nread;
-
- if(handle->dlcb) {
- handle->dlcb(filename, dl_thisfile, ust.size);
+ } else if(final_file) {
+ *final_file = strdup(strrchr(destfile, '/') + 1);
}
}
- /* did the transfer complete normally? */
- if (nread == -1) {
- /* not PM_ERR_LIBFETCH here because libfetch error string might be empty */
- pm_errno = PM_ERR_RETRIEVE;
- _alpm_log(PM_LOG_ERROR, _("failed retrieving file '%s' from %s\n"),
- filename, gethost(fileurl));
- ret = -1;
- goto cleanup;
+ if(dload_interrupted && should_unlink) {
+ unlink(tempfile);
}
- if (ust.size != -1 && dl_thisfile < ust.size) {
- pm_errno = PM_ERR_RETRIEVE;
- _alpm_log(PM_LOG_ERROR, _("%s appears to be truncated: %jd/%jd bytes\n"),
- filename, (intmax_t)dl_thisfile, (intmax_t)ust.size);
- ret = -1;
- goto cleanup;
- }
-
- /* probably safer to close the file descriptors now before renaming the file,
- * for example to make sure the buffers are flushed.
- */
- fclose(localf);
- localf = NULL;
- fetchIO_close(dlf);
- dlf = NULL;
-
- /* set the times on the file to the same as that of the remote file */
- if(ust.mtime) {
- struct timeval tv[2];
- memset(&tv, 0, sizeof(tv));
- tv[0].tv_sec = ust.atime;
- tv[1].tv_sec = ust.mtime;
- utimes(tempfile, tv);
- }
- if(rename(tempfile, destfile)) {
- _alpm_log(PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
- tempfile, destfile, strerror(errno));
- ret = -1;
- goto cleanup;
- }
- ret = 0;
-
-cleanup:
FREE(tempfile);
FREE(destfile);
- if(localf != NULL) {
- /* if we still had a local file open, we got interrupted. set the mtimes on
- * the file accordingly. */
- fflush(localf);
- if(ust.mtime) {
- struct timeval tv[2];
- memset(&tv, 0, sizeof(tv));
- tv[0].tv_sec = ust.atime;
- tv[1].tv_sec = ust.mtime;
- futimes(fileno(localf), tv);
- }
- fclose(localf);
- }
- if(dlf != NULL) {
- fetchIO_close(dlf);
- }
- fetchFreeURL(fileurl);
/* restore the old signal handlers */
sigaction(SIGINT, &sig_int[OLD], NULL);
@@ -341,106 +397,106 @@ cleanup:
raise(SIGINT);
}
- return(ret);
+ return ret;
}
#endif
-static int download(const char *url, const char *localpath,
- int force) {
+/** Download a file given by a URL to a local directory.
+ * Does not overwrite an existing file if the download fails.
+ * @param payload the payload context
+ * @param localpath the directory to save the file in
+ * @param final_file the real name of the downloaded file (may be NULL)
+ * @return 0 on success, -1 on error (pm_errno is set accordingly if errors_ok == 0)
+ */
+int _alpm_download(struct dload_payload *payload, const char *localpath,
+ char **final_file)
+{
+ alpm_handle_t *handle = payload->handle;
+
if(handle->fetchcb == NULL) {
-#ifdef HAVE_LIBFETCH
- return(download_internal(url, localpath, force));
+#ifdef HAVE_LIBCURL
+ return curl_download_internal(payload, localpath, final_file);
#else
- RET_ERR(PM_ERR_EXTERNAL_DOWNLOAD, -1);
+ RET_ERR(handle, ALPM_ERR_EXTERNAL_DOWNLOAD, -1);
#endif
} else {
- int ret = handle->fetchcb(url, localpath, force);
- if(ret == -1) {
- RET_ERR(PM_ERR_EXTERNAL_DOWNLOAD, -1);
+ int ret = handle->fetchcb(payload->fileurl, localpath, payload->force);
+ if(ret == -1 && !payload->errors_ok) {
+ RET_ERR(handle, ALPM_ERR_EXTERNAL_DOWNLOAD, -1);
}
- return(ret);
+ return ret;
}
}
-/*
- * Download a single file
- * - servers must be a list of urls WITHOUT trailing slashes.
- *
- * RETURN: 0 for successful download
- * 1 if the files are identical
- * -1 on error
- */
-int _alpm_download_single_file(const char *filename,
- alpm_list_t *servers, const char *localpath,
- int force)
+/** Fetch a remote pkg. */
+char SYMEXPORT *alpm_fetch_pkgurl(alpm_handle_t *handle, const char *url)
{
- alpm_list_t *i;
- int ret = -1;
+ char *filepath;
+ const char *cachedir;
+ char *final_file = NULL;
+ struct dload_payload *payload;
+ int ret;
- ASSERT(servers != NULL, RET_ERR(PM_ERR_SERVER_NONE, -1));
+ CHECK_HANDLE(handle, return NULL);
- for(i = servers; i; i = i->next) {
- const char *server = i->data;
- char *fileurl = NULL;
- size_t len;
+ /* find a valid cache dir to download to */
+ cachedir = _alpm_filecache_setup(handle);
- /* print server + filename into a buffer */
- len = strlen(server) + strlen(filename) + 2;
- CALLOC(fileurl, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, -1));
- snprintf(fileurl, len, "%s/%s", server, filename);
+ CALLOC(payload, 1, sizeof(*payload), RET_ERR(handle, ALPM_ERR_MEMORY, NULL));
+ payload->handle = handle;
+ payload->fileurl = strdup(url);
+ payload->allow_resume = 1;
- ret = download(fileurl, localpath, force);
- FREE(fileurl);
- if(ret != -1) {
- break;
- }
+ /* download the file */
+ ret = _alpm_download(payload, cachedir, &final_file);
+ if(ret == -1) {
+ _alpm_log(handle, ALPM_LOG_WARNING, _("failed to download %s\n"), url);
+ return NULL;
}
+ _alpm_log(handle, ALPM_LOG_DEBUG, "successfully downloaded %s\n", url);
- return(ret);
-}
-
-int _alpm_download_files(alpm_list_t *files,
- alpm_list_t *servers, const char *localpath)
-{
- int ret = 0;
- alpm_list_t *lp;
-
- for(lp = files; lp; lp = lp->next) {
- char *filename = lp->data;
- if(_alpm_download_single_file(filename, servers,
- localpath, 0) == -1) {
- ret++;
+ /* attempt to download the signature */
+ if(ret == 0 && (handle->siglevel & ALPM_SIG_PACKAGE)) {
+ char *sig_final_file = NULL;
+ size_t len;
+ struct dload_payload *sig_payload;
+
+ CALLOC(sig_payload, 1, sizeof(*sig_payload), RET_ERR(handle, ALPM_ERR_MEMORY, NULL));
+ len = strlen(url) + 5;
+ CALLOC(sig_payload->fileurl, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, NULL));
+ snprintf(sig_payload->fileurl, len, "%s.sig", url);
+ sig_payload->handle = handle;
+ sig_payload->force = 1;
+ sig_payload->errors_ok = (handle->siglevel & ALPM_SIG_PACKAGE_OPTIONAL);
+
+ ret = _alpm_download(sig_payload, cachedir, &sig_final_file);
+ if(ret == -1 && !sig_payload->errors_ok) {
+ _alpm_log(handle, ALPM_LOG_WARNING, _("failed to download %s\n"), sig_payload->fileurl);
+ /* Warn now, but don't return NULL. We will fail later during package
+ * load time. */
+ } else if(ret == 0) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "successfully downloaded %s\n", sig_payload->fileurl);
}
+ FREE(sig_final_file);
+ _alpm_dload_payload_free(sig_payload);
}
- return(ret);
-}
-
-/** Fetch a remote pkg. */
-char SYMEXPORT *alpm_fetch_pkgurl(const char *url)
-{
- char *filename, *filepath;
- const char *cachedir;
- int ret;
-
- ALPM_LOG_FUNC;
+ /* we should be able to find the file the second time around */
+ filepath = _alpm_filecache_find(handle, final_file);
+ FREE(final_file);
+ _alpm_dload_payload_free(payload);
- filename = get_filename(url);
+ return filepath;
+}
- /* find a valid cache dir to download to */
- cachedir = _alpm_filecache_setup();
+void _alpm_dload_payload_free(struct dload_payload *payload) {
+ struct dload_payload *load = (struct dload_payload *)payload;
- /* download the file */
- ret = download(url, cachedir, 0);
- if(ret == -1) {
- _alpm_log(PM_LOG_WARNING, _("failed to download %s\n"), url);
- return(NULL);
- }
- _alpm_log(PM_LOG_DEBUG, "successfully downloaded %s\n", url);
+ ASSERT(load, return);
- /* we should be able to find the file the second time around */
- filepath = _alpm_filecache_find(filename);
- return(filepath);
+ FREE(load->fileurl);
+ FREE(load->cd_filename);
+ FREE(load);
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/dload.h b/lib/libalpm/dload.h
index 63266491..341a4a1a 100644
--- a/lib/libalpm/dload.h
+++ b/lib/libalpm/dload.h
@@ -25,14 +25,22 @@
#include <time.h>
-#define PM_DLBUF_LEN (1024 * 16)
+struct dload_payload {
+ alpm_handle_t *handle;
+ const char *filename;
+ char *cd_filename;
+ char *fileurl;
+ double initial_size;
+ long max_size;
+ int force;
+ int allow_resume;
+ int errors_ok;
+};
-int _alpm_download_single_file(const char *filename,
- alpm_list_t *servers, const char *localpath,
- int force);
+void _alpm_dload_payload_free(struct dload_payload *payload);
-int _alpm_download_files(alpm_list_t *files,
- alpm_list_t *servers, const char *localpath);
+int _alpm_download(struct dload_payload *payload, const char *localpath,
+ char **final_file);
#endif /* _ALPM_DLOAD_H */
diff --git a/lib/libalpm/error.c b/lib/libalpm/error.c
index 21fbb48f..7e0e5c85 100644
--- a/lib/libalpm/error.c
+++ b/lib/libalpm/error.c
@@ -20,141 +20,140 @@
#include "config.h"
-/* TODO: needed for the libfetch stuff, unfortunately- we should kill it */
-#include <stdio.h>
-/* the following two are needed for FreeBSD's libfetch */
-#include <limits.h> /* PATH_MAX */
-#if defined(HAVE_SYS_PARAM_H)
-#include <sys/param.h> /* MAXHOSTNAMELEN */
-#endif
-
-#ifdef HAVE_LIBFETCH
-#include <fetch.h> /* fetchLastErrString */
+#ifdef HAVE_LIBCURL
+#include <curl/curl.h>
#endif
/* libalpm */
#include "util.h"
#include "alpm.h"
+#include "handle.h"
-const char SYMEXPORT *alpm_strerrorlast(void)
+enum _alpm_errno_t SYMEXPORT alpm_errno(alpm_handle_t *handle)
{
- return alpm_strerror(pm_errno);
+ return handle->pm_errno;
}
-const char SYMEXPORT *alpm_strerror(int err)
+const char SYMEXPORT *alpm_strerror(enum _alpm_errno_t err)
{
switch(err) {
/* System */
- case PM_ERR_MEMORY:
+ case ALPM_ERR_MEMORY:
return _("out of memory!");
- case PM_ERR_SYSTEM:
+ case ALPM_ERR_SYSTEM:
return _("unexpected system error");
- case PM_ERR_BADPERMS:
+ case ALPM_ERR_BADPERMS:
return _("insufficient privileges");
- case PM_ERR_NOT_A_FILE:
+ case ALPM_ERR_NOT_A_FILE:
return _("could not find or read file");
- case PM_ERR_NOT_A_DIR:
+ case ALPM_ERR_NOT_A_DIR:
return _("could not find or read directory");
- case PM_ERR_WRONG_ARGS:
+ case ALPM_ERR_WRONG_ARGS:
return _("wrong or NULL argument passed");
- case PM_ERR_DISK_SPACE:
+ case ALPM_ERR_DISK_SPACE:
return _("not enough free disk space");
/* Interface */
- case PM_ERR_HANDLE_NULL:
+ case ALPM_ERR_HANDLE_NULL:
return _("library not initialized");
- case PM_ERR_HANDLE_NOT_NULL:
+ case ALPM_ERR_HANDLE_NOT_NULL:
return _("library already initialized");
- case PM_ERR_HANDLE_LOCK:
+ case ALPM_ERR_HANDLE_LOCK:
return _("unable to lock database");
/* Databases */
- case PM_ERR_DB_OPEN:
+ case ALPM_ERR_DB_OPEN:
return _("could not open database");
- case PM_ERR_DB_CREATE:
+ case ALPM_ERR_DB_CREATE:
return _("could not create database");
- case PM_ERR_DB_NULL:
+ case ALPM_ERR_DB_NULL:
return _("database not initialized");
- case PM_ERR_DB_NOT_NULL:
+ case ALPM_ERR_DB_NOT_NULL:
return _("database already registered");
- case PM_ERR_DB_NOT_FOUND:
+ case ALPM_ERR_DB_NOT_FOUND:
return _("could not find database");
- case PM_ERR_DB_VERSION:
+ case ALPM_ERR_DB_INVALID:
+ return _("invalid or corrupted database");
+ case ALPM_ERR_DB_INVALID_SIG:
+ return _("invalid or corrupted database (PGP signature)");
+ case ALPM_ERR_DB_VERSION:
return _("database is incorrect version");
- case PM_ERR_DB_WRITE:
+ case ALPM_ERR_DB_WRITE:
return _("could not update database");
- case PM_ERR_DB_REMOVE:
+ case ALPM_ERR_DB_REMOVE:
return _("could not remove database entry");
/* Servers */
- case PM_ERR_SERVER_BAD_URL:
+ case ALPM_ERR_SERVER_BAD_URL:
return _("invalid url for server");
- case PM_ERR_SERVER_NONE:
+ case ALPM_ERR_SERVER_NONE:
return _("no servers configured for repository");
/* Transactions */
- case PM_ERR_TRANS_NOT_NULL:
+ case ALPM_ERR_TRANS_NOT_NULL:
return _("transaction already initialized");
- case PM_ERR_TRANS_NULL:
+ case ALPM_ERR_TRANS_NULL:
return _("transaction not initialized");
- case PM_ERR_TRANS_DUP_TARGET:
+ case ALPM_ERR_TRANS_DUP_TARGET:
return _("duplicate target");
- case PM_ERR_TRANS_NOT_INITIALIZED:
+ case ALPM_ERR_TRANS_NOT_INITIALIZED:
return _("transaction not initialized");
- case PM_ERR_TRANS_NOT_PREPARED:
+ case ALPM_ERR_TRANS_NOT_PREPARED:
return _("transaction not prepared");
- case PM_ERR_TRANS_ABORT:
+ case ALPM_ERR_TRANS_ABORT:
return _("transaction aborted");
- case PM_ERR_TRANS_TYPE:
+ case ALPM_ERR_TRANS_TYPE:
return _("operation not compatible with the transaction type");
- case PM_ERR_TRANS_NOT_LOCKED:
+ case ALPM_ERR_TRANS_NOT_LOCKED:
return _("transaction commit attempt when database is not locked");
/* Packages */
- case PM_ERR_PKG_NOT_FOUND:
+ case ALPM_ERR_PKG_NOT_FOUND:
return _("could not find or read package");
- case PM_ERR_PKG_IGNORED:
+ case ALPM_ERR_PKG_IGNORED:
return _("operation cancelled due to ignorepkg");
- case PM_ERR_PKG_INVALID:
- return _("invalid or corrupted package");
- case PM_ERR_PKG_OPEN:
+ case ALPM_ERR_PKG_INVALID:
+ return _("invalid or corrupted package (checksum)");
+ case ALPM_ERR_PKG_INVALID_SIG:
+ return _("invalid or corrupted package (PGP signature)");
+ case ALPM_ERR_PKG_OPEN:
return _("cannot open package file");
- case PM_ERR_PKG_CANT_REMOVE:
+ case ALPM_ERR_PKG_CANT_REMOVE:
return _("cannot remove all files for package");
- case PM_ERR_PKG_INVALID_NAME:
+ case ALPM_ERR_PKG_INVALID_NAME:
return _("package filename is not valid");
- case PM_ERR_PKG_INVALID_ARCH:
+ case ALPM_ERR_PKG_INVALID_ARCH:
return _("package architecture is not valid");
- case PM_ERR_PKG_REPO_NOT_FOUND:
+ case ALPM_ERR_PKG_REPO_NOT_FOUND:
return _("could not find repository for target");
+ /* Signatures */
+ case ALPM_ERR_SIG_MISSING:
+ return _("missing PGP signature");
+ case ALPM_ERR_SIG_INVALID:
+ return _("invalid PGP signature");
/* Deltas */
- case PM_ERR_DLT_INVALID:
+ case ALPM_ERR_DLT_INVALID:
return _("invalid or corrupted delta");
- case PM_ERR_DLT_PATCHFAILED:
+ case ALPM_ERR_DLT_PATCHFAILED:
return _("delta patch failed");
/* Dependencies */
- case PM_ERR_UNSATISFIED_DEPS:
+ case ALPM_ERR_UNSATISFIED_DEPS:
return _("could not satisfy dependencies");
- case PM_ERR_CONFLICTING_DEPS:
+ case ALPM_ERR_CONFLICTING_DEPS:
return _("conflicting dependencies");
- case PM_ERR_FILE_CONFLICTS:
+ case ALPM_ERR_FILE_CONFLICTS:
return _("conflicting files");
/* Miscellaenous */
- case PM_ERR_RETRIEVE:
+ case ALPM_ERR_RETRIEVE:
return _("failed to retrieve some files");
- case PM_ERR_WRITE:
- return _("failed to copy some file");
- case PM_ERR_INVALID_REGEX:
+ case ALPM_ERR_INVALID_REGEX:
return _("invalid regular expression");
/* Errors from external libraries- our own wrapper error */
- case PM_ERR_LIBARCHIVE:
+ case ALPM_ERR_LIBARCHIVE:
/* it would be nice to use archive_error_string() here, but that
* requires the archive struct, so we can't. Just use a generic
* error string instead. */
return _("libarchive error");
- case PM_ERR_LIBFETCH:
-#ifdef HAVE_LIBFETCH
- return fetchLastErrString;
-#else
- /* obviously shouldn't get here... */
+ case ALPM_ERR_LIBCURL:
return _("download library error");
-#endif
- case PM_ERR_EXTERNAL_DOWNLOAD:
+ case ALPM_ERR_GPGME:
+ return _("gpgme error");
+ case ALPM_ERR_EXTERNAL_DOWNLOAD:
return _("error invoking external downloader");
/* Unknown error! */
default:
diff --git a/lib/libalpm/graph.c b/lib/libalpm/graph.c
new file mode 100644
index 00000000..3a7f24b8
--- /dev/null
+++ b/lib/libalpm/graph.c
@@ -0,0 +1,41 @@
+/*
+ * graph.c - helpful graph structure and setup/teardown methods
+ *
+ * Copyright (c) 2007-2011 Pacman Development Team <pacman-dev@archlinux.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 "graph.h"
+#include "util.h"
+#include "log.h"
+
+alpm_graph_t *_alpm_graph_new(void)
+{
+ alpm_graph_t *graph = NULL;
+
+ CALLOC(graph, 1, sizeof(alpm_graph_t), return NULL);
+ return graph;
+}
+
+void _alpm_graph_free(void *data)
+{
+ alpm_graph_t *graph = data;
+ alpm_list_free(graph->children);
+ free(graph);
+}
+
+/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/graph.h b/lib/libalpm/graph.h
index 07986f66..d4d134b5 100644
--- a/lib/libalpm/graph.h
+++ b/lib/libalpm/graph.h
@@ -1,8 +1,7 @@
/*
* graph.h - helpful graph structure and setup/teardown methods
*
- * Copyright (c) 2006-2011 Pacman Development Team <pacman-dev@archlinux.org>
- * Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
+ * Copyright (c) 2007-2011 Pacman Development Team <pacman-dev@archlinux.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
@@ -17,34 +16,27 @@
* 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 _ALPM_GRAPH_H
+#define _ALPM_GRAPH_H
+
+#include "config.h" /* ensure off_t is correct length */
#include <sys/types.h> /* off_t */
#include "alpm_list.h"
-#include "util.h" /* CALLOC() */
-struct __pmgraph_t {
+typedef struct __alpm_graph_t {
char state; /* 0: untouched, -1: entered, other: leaving time */
- void *data;
off_t weight; /* weight of the node */
- struct __pmgraph_t *parent; /* where did we come from? */
+ void *data;
+ struct __alpm_graph_t *parent; /* where did we come from? */
alpm_list_t *children;
alpm_list_t *childptr; /* points to a child in children list */
-};
-typedef struct __pmgraph_t pmgraph_t;
-
-static pmgraph_t *_alpm_graph_new(void)
-{
- pmgraph_t *graph = NULL;
+} alpm_graph_t;
- CALLOC(graph, 1, sizeof(pmgraph_t), RET_ERR(PM_ERR_MEMORY, NULL));
- return(graph);
-}
+alpm_graph_t *_alpm_graph_new(void);
+void _alpm_graph_free(void *data);
-static void _alpm_graph_free(void *data)
-{
- pmgraph_t *graph = data;
- alpm_list_free(graph->children);
- free(graph);
-}
+#endif /* _ALPM_GRAPH_H */
+/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/group.c b/lib/libalpm/group.c
index 398c2588..47458df2 100644
--- a/lib/libalpm/group.c
+++ b/lib/libalpm/group.c
@@ -21,7 +21,6 @@
#include "config.h"
#include <stdlib.h>
-#include <stdio.h>
#include <string.h>
/* libalpm */
@@ -31,22 +30,18 @@
#include "log.h"
#include "alpm.h"
-pmgrp_t *_alpm_grp_new(const char *name)
+alpm_group_t *_alpm_group_new(const char *name)
{
- pmgrp_t* grp;
+ alpm_group_t* grp;
- ALPM_LOG_FUNC;
+ CALLOC(grp, 1, sizeof(alpm_group_t), return NULL);
+ STRDUP(grp->name, name, free(grp); return NULL);
- CALLOC(grp, 1, sizeof(pmgrp_t), RET_ERR(PM_ERR_MEMORY, NULL));
- STRDUP(grp->name, name, RET_ERR(PM_ERR_MEMORY, NULL));
-
- return(grp);
+ return grp;
}
-void _alpm_grp_free(pmgrp_t *grp)
+void _alpm_group_free(alpm_group_t *grp)
{
- ALPM_LOG_FUNC;
-
if(grp == NULL) {
return;
}
@@ -57,23 +52,4 @@ void _alpm_grp_free(pmgrp_t *grp)
FREE(grp);
}
-const char SYMEXPORT *alpm_grp_get_name(const pmgrp_t *grp)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(grp != NULL, return(NULL));
-
- return grp->name;
-}
-
-alpm_list_t SYMEXPORT *alpm_grp_get_pkgs(const pmgrp_t *grp)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(grp != NULL, return(NULL));
-
- return grp->packages;
-}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/group.h b/lib/libalpm/group.h
index c92684e3..078c9af7 100644
--- a/lib/libalpm/group.h
+++ b/lib/libalpm/group.h
@@ -22,15 +22,8 @@
#include "alpm.h"
-struct __pmgrp_t {
- /** group name */
- char *name;
- /** list of pmpkg_t packages */
- alpm_list_t *packages;
-};
-
-pmgrp_t *_alpm_grp_new(const char *name);
-void _alpm_grp_free(pmgrp_t *grp);
+alpm_group_t *_alpm_group_new(const char *name);
+void _alpm_group_free(alpm_group_t *grp);
#endif /* _ALPM_GROUP_H */
diff --git a/lib/libalpm/handle.c b/lib/libalpm/handle.c
index 586aad1e..266b4bc8 100644
--- a/lib/libalpm/handle.c
+++ b/lib/libalpm/handle.c
@@ -22,14 +22,14 @@
#include "config.h"
+#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <sys/types.h>
#include <syslog.h>
-#include <time.h>
#include <sys/stat.h>
-#include <errno.h>
+#include <fcntl.h>
/* libalpm */
#include "handle.h"
@@ -39,22 +39,22 @@
#include "trans.h"
#include "alpm.h"
-/* global var for handle (private to libalpm) */
-pmhandle_t *handle = NULL;
-
-pmhandle_t *_alpm_handle_new()
+alpm_handle_t *_alpm_handle_new()
{
- pmhandle_t *handle;
+ alpm_handle_t *handle;
- CALLOC(handle, 1, sizeof(pmhandle_t), RET_ERR(PM_ERR_MEMORY, NULL));
+ CALLOC(handle, 1, sizeof(alpm_handle_t), return NULL);
- return(handle);
+#ifdef HAVE_LIBGPGME
+ handle->siglevel = ALPM_SIG_PACKAGE | ALPM_SIG_PACKAGE_OPTIONAL |
+ ALPM_SIG_DATABASE | ALPM_SIG_DATABASE_OPTIONAL;
+#endif
+
+ return handle;
}
-void _alpm_handle_free(pmhandle_t *handle)
+void _alpm_handle_free(alpm_handle_t *handle)
{
- ALPM_LOG_FUNC;
-
if(handle == NULL) {
return;
}
@@ -69,6 +69,11 @@ void _alpm_handle_free(pmhandle_t *handle)
closelog();
}
+#ifdef HAVE_LIBCURL
+ /* release curl handle */
+ curl_easy_cleanup(handle->curl);
+#endif
+
/* free memory */
_alpm_trans_free(handle->trans);
FREE(handle->root);
@@ -77,371 +82,326 @@ void _alpm_handle_free(pmhandle_t *handle)
FREE(handle->logfile);
FREE(handle->lockfile);
FREE(handle->arch);
+ FREE(handle->gpgdir);
FREELIST(handle->dbs_sync);
FREELIST(handle->noupgrade);
FREELIST(handle->noextract);
FREELIST(handle->ignorepkg);
- FREELIST(handle->ignoregrp);
+ FREELIST(handle->ignoregroup);
FREE(handle);
}
-alpm_cb_log SYMEXPORT alpm_option_get_logcb()
+/** Lock the database */
+int _alpm_handle_lock(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
+ int fd;
+ char *dir, *ptr;
+
+ ASSERT(handle->lockfile != NULL, return -1);
+ ASSERT(handle->lckstream == NULL, return 0);
+
+ /* create the dir of the lockfile first */
+ dir = strdup(handle->lockfile);
+ ptr = strrchr(dir, '/');
+ if(ptr) {
+ *ptr = '\0';
}
- return handle->logcb;
+ if(_alpm_makepath(dir)) {
+ FREE(dir);
+ return -1;
+ }
+ FREE(dir);
+
+ do {
+ fd = open(handle->lockfile, O_WRONLY | O_CREAT | O_EXCL, 0000);
+ } while(fd == -1 && errno == EINTR);
+ if(fd > 0) {
+ FILE *f = fdopen(fd, "w");
+ fprintf(f, "%ld\n", (long)getpid());
+ fflush(f);
+ fsync(fd);
+ handle->lckstream = f;
+ return 0;
+ }
+ return -1;
}
-alpm_cb_download SYMEXPORT alpm_option_get_dlcb()
+/** Remove a lock file */
+int _alpm_handle_unlock(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
+ ASSERT(handle->lockfile != NULL, return -1);
+ ASSERT(handle->lckstream != NULL, return 0);
+
+ if(handle->lckstream != NULL) {
+ fclose(handle->lckstream);
+ handle->lckstream = NULL;
+ }
+ if(unlink(handle->lockfile) && errno != ENOENT) {
+ return -1;
}
+ return 0;
+}
+
+
+alpm_cb_log SYMEXPORT alpm_option_get_logcb(alpm_handle_t *handle)
+{
+ CHECK_HANDLE(handle, return NULL);
+ return handle->logcb;
+}
+
+alpm_cb_download SYMEXPORT alpm_option_get_dlcb(alpm_handle_t *handle)
+{
+ CHECK_HANDLE(handle, return NULL);
return handle->dlcb;
}
-alpm_cb_fetch SYMEXPORT alpm_option_get_fetchcb()
+alpm_cb_fetch SYMEXPORT alpm_option_get_fetchcb(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
+ CHECK_HANDLE(handle, return NULL);
return handle->fetchcb;
}
-alpm_cb_totaldl SYMEXPORT alpm_option_get_totaldlcb()
+alpm_cb_totaldl SYMEXPORT alpm_option_get_totaldlcb(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
+ CHECK_HANDLE(handle, return NULL);
return handle->totaldlcb;
}
-const char SYMEXPORT *alpm_option_get_root()
+const char SYMEXPORT *alpm_option_get_root(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
+ CHECK_HANDLE(handle, return NULL);
return handle->root;
}
-const char SYMEXPORT *alpm_option_get_dbpath()
+const char SYMEXPORT *alpm_option_get_dbpath(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
+ CHECK_HANDLE(handle, return NULL);
return handle->dbpath;
}
-alpm_list_t SYMEXPORT *alpm_option_get_cachedirs()
+alpm_list_t SYMEXPORT *alpm_option_get_cachedirs(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
+ CHECK_HANDLE(handle, return NULL);
return handle->cachedirs;
}
-const char SYMEXPORT *alpm_option_get_logfile()
+const char SYMEXPORT *alpm_option_get_logfile(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
+ CHECK_HANDLE(handle, return NULL);
return handle->logfile;
}
-const char SYMEXPORT *alpm_option_get_lockfile()
+const char SYMEXPORT *alpm_option_get_lockfile(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
+ CHECK_HANDLE(handle, return NULL);
return handle->lockfile;
}
-int SYMEXPORT alpm_option_get_usesyslog()
+const char SYMEXPORT *alpm_option_get_gpgdir(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return -1;
- }
+ CHECK_HANDLE(handle, return NULL);
+ return handle->gpgdir;
+}
+
+int SYMEXPORT alpm_option_get_usesyslog(alpm_handle_t *handle)
+{
+ CHECK_HANDLE(handle, return -1);
return handle->usesyslog;
}
-alpm_list_t SYMEXPORT *alpm_option_get_noupgrades()
+alpm_list_t SYMEXPORT *alpm_option_get_noupgrades(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
+ CHECK_HANDLE(handle, return NULL);
return handle->noupgrade;
}
-alpm_list_t SYMEXPORT *alpm_option_get_noextracts()
+alpm_list_t SYMEXPORT *alpm_option_get_noextracts(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
+ CHECK_HANDLE(handle, return NULL);
return handle->noextract;
}
-alpm_list_t SYMEXPORT *alpm_option_get_ignorepkgs()
+alpm_list_t SYMEXPORT *alpm_option_get_ignorepkgs(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
+ CHECK_HANDLE(handle, return NULL);
return handle->ignorepkg;
}
-alpm_list_t SYMEXPORT *alpm_option_get_ignoregrps()
+alpm_list_t SYMEXPORT *alpm_option_get_ignoregroups(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
- return handle->ignoregrp;
+ CHECK_HANDLE(handle, return NULL);
+ return handle->ignoregroup;
}
-const char SYMEXPORT *alpm_option_get_arch()
+const char SYMEXPORT *alpm_option_get_arch(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
+ CHECK_HANDLE(handle, return NULL);
return handle->arch;
}
-int SYMEXPORT alpm_option_get_usedelta()
+int SYMEXPORT alpm_option_get_usedelta(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return -1;
- }
+ CHECK_HANDLE(handle, return -1);
return handle->usedelta;
}
-int SYMEXPORT alpm_option_get_checkspace()
+int SYMEXPORT alpm_option_get_checkspace(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return -1;
- }
+ CHECK_HANDLE(handle, return -1);
return handle->checkspace;
}
-pmdb_t SYMEXPORT *alpm_option_get_localdb()
+alpm_db_t SYMEXPORT *alpm_option_get_localdb(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
+ CHECK_HANDLE(handle, return NULL);
return handle->db_local;
}
-alpm_list_t SYMEXPORT *alpm_option_get_syncdbs()
+alpm_list_t SYMEXPORT *alpm_option_get_syncdbs(alpm_handle_t *handle)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return NULL;
- }
+ CHECK_HANDLE(handle, return NULL);
return handle->dbs_sync;
}
-void SYMEXPORT alpm_option_set_logcb(alpm_cb_log cb)
+int SYMEXPORT alpm_option_set_logcb(alpm_handle_t *handle, alpm_cb_log cb)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return;
- }
+ CHECK_HANDLE(handle, return -1);
handle->logcb = cb;
+ return 0;
}
-void SYMEXPORT alpm_option_set_dlcb(alpm_cb_download cb)
+int SYMEXPORT alpm_option_set_dlcb(alpm_handle_t *handle, alpm_cb_download cb)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return;
- }
+ CHECK_HANDLE(handle, return -1);
handle->dlcb = cb;
+ return 0;
}
-void SYMEXPORT alpm_option_set_fetchcb(alpm_cb_fetch cb)
+int SYMEXPORT alpm_option_set_fetchcb(alpm_handle_t *handle, alpm_cb_fetch cb)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return;
- }
+ CHECK_HANDLE(handle, return -1);
handle->fetchcb = cb;
+ return 0;
}
-void SYMEXPORT alpm_option_set_totaldlcb(alpm_cb_totaldl cb)
+int SYMEXPORT alpm_option_set_totaldlcb(alpm_handle_t *handle, alpm_cb_totaldl cb)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return;
- }
+ CHECK_HANDLE(handle, return -1);
handle->totaldlcb = cb;
+ return 0;
}
-int SYMEXPORT alpm_option_set_root(const char *root)
-{
- struct stat st;
- char *realroot;
- size_t rootlen;
-
- ALPM_LOG_FUNC;
-
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+static char *canonicalize_path(const char *path) {
+ char *new_path;
+ size_t len;
- if(!root) {
- pm_errno = PM_ERR_WRONG_ARGS;
- return(-1);
+ /* verify path ends in a '/' */
+ len = strlen(path);
+ if(path[len - 1] != '/') {
+ len += 1;
}
- if(stat(root, &st) == -1 || !S_ISDIR(st.st_mode)) {
- pm_errno = PM_ERR_NOT_A_DIR;
- return(-1);
- }
-
- realroot = calloc(PATH_MAX+1, sizeof(char));
- if(!realpath(root, realroot)) {
- FREE(realroot);
- pm_errno = PM_ERR_NOT_A_DIR;
- return(-1);
- }
-
- /* verify root ends in a '/' */
- rootlen = strlen(realroot);
- if(realroot[rootlen-1] != '/') {
- rootlen += 1;
- }
- if(handle->root) {
- FREE(handle->root);
- }
- handle->root = calloc(rootlen + 1, sizeof(char));
- strncpy(handle->root, realroot, rootlen);
- handle->root[rootlen-1] = '/';
- FREE(realroot);
- _alpm_log(PM_LOG_DEBUG, "option 'root' = %s\n", handle->root);
- return(0);
+ CALLOC(new_path, len + 1, sizeof(char), return NULL);
+ strcpy(new_path, path);
+ new_path[len - 1] = '/';
+ return new_path;
}
-int SYMEXPORT alpm_option_set_dbpath(const char *dbpath)
-{
+enum _alpm_errno_t _alpm_set_directory_option(const char *value,
+ char **storage, int must_exist)
+ {
struct stat st;
- size_t dbpathlen, lockfilelen;
- const char *lf = "db.lck";
-
- ALPM_LOG_FUNC;
+ char *real = NULL;
+ const char *path;
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
- if(!dbpath) {
- pm_errno = PM_ERR_WRONG_ARGS;
- return(-1);
- }
- if(stat(dbpath, &st) == -1 || !S_ISDIR(st.st_mode)) {
- pm_errno = PM_ERR_NOT_A_DIR;
- return(-1);
+ path = value;
+ if(!path) {
+ return ALPM_ERR_WRONG_ARGS;
}
- /* verify dbpath ends in a '/' */
- dbpathlen = strlen(dbpath);
- if(dbpath[dbpathlen-1] != '/') {
- dbpathlen += 1;
+ if(must_exist) {
+ if(stat(path, &st) == -1 || !S_ISDIR(st.st_mode)) {
+ return ALPM_ERR_NOT_A_DIR;
+ }
+ CALLOC(real, PATH_MAX, sizeof(char), return ALPM_ERR_MEMORY);
+ if(!realpath(path, real)) {
+ free(real);
+ return ALPM_ERR_NOT_A_DIR;
+ }
+ path = real;
}
- if(handle->dbpath) {
- FREE(handle->dbpath);
- }
- handle->dbpath = calloc(dbpathlen+1, sizeof(char));
- strncpy(handle->dbpath, dbpath, dbpathlen);
- handle->dbpath[dbpathlen-1] = '/';
- _alpm_log(PM_LOG_DEBUG, "option 'dbpath' = %s\n", handle->dbpath);
- if(handle->lockfile) {
- FREE(handle->lockfile);
+ if(*storage) {
+ FREE(*storage);
+ }
+ *storage = canonicalize_path(path);
+ if(!*storage) {
+ return ALPM_ERR_MEMORY;
}
- lockfilelen = strlen(handle->dbpath) + strlen(lf) + 1;
- handle->lockfile = calloc(lockfilelen, sizeof(char));
- snprintf(handle->lockfile, lockfilelen, "%s%s", handle->dbpath, lf);
- _alpm_log(PM_LOG_DEBUG, "option 'lockfile' = %s\n", handle->lockfile);
- return(0);
+ free(real);
+ return 0;
}
-int SYMEXPORT alpm_option_add_cachedir(const char *cachedir)
+int SYMEXPORT alpm_option_add_cachedir(alpm_handle_t *handle, const char *cachedir)
{
char *newcachedir;
- size_t cachedirlen;
- ALPM_LOG_FUNC;
-
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
- if(!cachedir) {
- pm_errno = PM_ERR_WRONG_ARGS;
- return(-1);
- }
+ CHECK_HANDLE(handle, return -1);
+ ASSERT(cachedir != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
/* don't stat the cachedir yet, as it may not even be needed. we can
* fail later if it is needed and the path is invalid. */
- /* verify cachedir ends in a '/' */
- cachedirlen = strlen(cachedir);
- if(cachedir[cachedirlen-1] != '/') {
- cachedirlen += 1;
+ newcachedir = canonicalize_path(cachedir);
+ if(!newcachedir) {
+ RET_ERR(handle, ALPM_ERR_MEMORY, -1);
}
- newcachedir = calloc(cachedirlen + 1, sizeof(char));
- strncpy(newcachedir, cachedir, cachedirlen);
- newcachedir[cachedirlen-1] = '/';
handle->cachedirs = alpm_list_add(handle->cachedirs, newcachedir);
- _alpm_log(PM_LOG_DEBUG, "option 'cachedir' = %s\n", newcachedir);
- return(0);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "option 'cachedir' = %s\n", newcachedir);
+ return 0;
}
-void SYMEXPORT alpm_option_set_cachedirs(alpm_list_t *cachedirs)
+int SYMEXPORT alpm_option_set_cachedirs(alpm_handle_t *handle, alpm_list_t *cachedirs)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
- if(handle->cachedirs) FREELIST(handle->cachedirs);
- if(cachedirs) handle->cachedirs = cachedirs;
+ alpm_list_t *i;
+ CHECK_HANDLE(handle, return -1);
+ if(handle->cachedirs) {
+ FREELIST(handle->cachedirs);
+ }
+ for(i = cachedirs; i; i = i->next) {
+ int ret = alpm_option_add_cachedir(handle, i->data);
+ if(ret) {
+ return ret;
+ }
+ }
+ return 0;
}
-int SYMEXPORT alpm_option_remove_cachedir(const char *cachedir)
+int SYMEXPORT alpm_option_remove_cachedir(alpm_handle_t *handle, const char *cachedir)
{
char *vdata = NULL;
char *newcachedir;
- size_t cachedirlen;
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
- /* verify cachedir ends in a '/' */
- cachedirlen = strlen(cachedir);
- if(cachedir[cachedirlen-1] != '/') {
- cachedirlen += 1;
+ CHECK_HANDLE(handle, return -1);
+ ASSERT(cachedir != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
+
+ newcachedir = canonicalize_path(cachedir);
+ if(!newcachedir) {
+ RET_ERR(handle, ALPM_ERR_MEMORY, -1);
}
- newcachedir = calloc(cachedirlen + 1, sizeof(char));
- strncpy(newcachedir, cachedir, cachedirlen);
- newcachedir[cachedirlen-1] = '/';
handle->cachedirs = alpm_list_remove_str(handle->cachedirs, newcachedir, &vdata);
FREE(newcachedir);
if(vdata != NULL) {
FREE(vdata);
- return(1);
+ return 1;
}
- return(0);
+ return 0;
}
-int SYMEXPORT alpm_option_set_logfile(const char *logfile)
+int SYMEXPORT alpm_option_set_logfile(alpm_handle_t *handle, const char *logfile)
{
char *oldlogfile = handle->logfile;
- ALPM_LOG_FUNC;
-
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
if(!logfile) {
- pm_errno = PM_ERR_WRONG_ARGS;
- return(-1);
+ handle->pm_errno = ALPM_ERR_WRONG_ARGS;
+ return -1;
}
handle->logfile = strdup(logfile);
@@ -455,133 +415,186 @@ int SYMEXPORT alpm_option_set_logfile(const char *logfile)
fclose(handle->logstream);
handle->logstream = NULL;
}
- _alpm_log(PM_LOG_DEBUG, "option 'logfile' = %s\n", handle->logfile);
- return(0);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "option 'logfile' = %s\n", handle->logfile);
+ return 0;
}
-void SYMEXPORT alpm_option_set_usesyslog(int usesyslog)
+int SYMEXPORT alpm_option_set_gpgdir(alpm_handle_t *handle, const char *gpgdir)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ CHECK_HANDLE(handle, return -1);
+ if(!gpgdir) {
+ handle->pm_errno = ALPM_ERR_WRONG_ARGS;
+ return -1;
+ }
+
+ if(handle->gpgdir) {
+ FREE(handle->gpgdir);
+ }
+ handle->gpgdir = strdup(gpgdir);
+
+ _alpm_log(handle, ALPM_LOG_DEBUG, "option 'gpgdir' = %s\n", handle->gpgdir);
+ return 0;
+}
+
+int SYMEXPORT alpm_option_set_usesyslog(alpm_handle_t *handle, int usesyslog)
+{
+ CHECK_HANDLE(handle, return -1);
handle->usesyslog = usesyslog;
+ return 0;
}
-void SYMEXPORT alpm_option_add_noupgrade(const char *pkg)
+int SYMEXPORT alpm_option_add_noupgrade(alpm_handle_t *handle, const char *pkg)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ CHECK_HANDLE(handle, return -1);
handle->noupgrade = alpm_list_add(handle->noupgrade, strdup(pkg));
+ return 0;
}
-void SYMEXPORT alpm_option_set_noupgrades(alpm_list_t *noupgrade)
+int SYMEXPORT alpm_option_set_noupgrades(alpm_handle_t *handle, alpm_list_t *noupgrade)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ CHECK_HANDLE(handle, return -1);
if(handle->noupgrade) FREELIST(handle->noupgrade);
- if(noupgrade) handle->noupgrade = noupgrade;
+ handle->noupgrade = alpm_list_strdup(noupgrade);
+ return 0;
}
-int SYMEXPORT alpm_option_remove_noupgrade(const char *pkg)
+int SYMEXPORT alpm_option_remove_noupgrade(alpm_handle_t *handle, const char *pkg)
{
char *vdata = NULL;
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
handle->noupgrade = alpm_list_remove_str(handle->noupgrade, pkg, &vdata);
if(vdata != NULL) {
FREE(vdata);
- return(1);
+ return 1;
}
- return(0);
+ return 0;
}
-void SYMEXPORT alpm_option_add_noextract(const char *pkg)
+int SYMEXPORT alpm_option_add_noextract(alpm_handle_t *handle, const char *pkg)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ CHECK_HANDLE(handle, return -1);
handle->noextract = alpm_list_add(handle->noextract, strdup(pkg));
+ return 0;
}
-void SYMEXPORT alpm_option_set_noextracts(alpm_list_t *noextract)
+int SYMEXPORT alpm_option_set_noextracts(alpm_handle_t *handle, alpm_list_t *noextract)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ CHECK_HANDLE(handle, return -1);
if(handle->noextract) FREELIST(handle->noextract);
- if(noextract) handle->noextract = noextract;
+ handle->noextract = alpm_list_strdup(noextract);
+ return 0;
}
-int SYMEXPORT alpm_option_remove_noextract(const char *pkg)
+int SYMEXPORT alpm_option_remove_noextract(alpm_handle_t *handle, const char *pkg)
{
char *vdata = NULL;
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
handle->noextract = alpm_list_remove_str(handle->noextract, pkg, &vdata);
if(vdata != NULL) {
FREE(vdata);
- return(1);
+ return 1;
}
- return(0);
+ return 0;
}
-void SYMEXPORT alpm_option_add_ignorepkg(const char *pkg)
+int SYMEXPORT alpm_option_add_ignorepkg(alpm_handle_t *handle, const char *pkg)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ CHECK_HANDLE(handle, return -1);
handle->ignorepkg = alpm_list_add(handle->ignorepkg, strdup(pkg));
+ return 0;
}
-void SYMEXPORT alpm_option_set_ignorepkgs(alpm_list_t *ignorepkgs)
+int SYMEXPORT alpm_option_set_ignorepkgs(alpm_handle_t *handle, alpm_list_t *ignorepkgs)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ CHECK_HANDLE(handle, return -1);
if(handle->ignorepkg) FREELIST(handle->ignorepkg);
- if(ignorepkgs) handle->ignorepkg = ignorepkgs;
+ handle->ignorepkg = alpm_list_strdup(ignorepkgs);
+ return 0;
}
-int SYMEXPORT alpm_option_remove_ignorepkg(const char *pkg)
+int SYMEXPORT alpm_option_remove_ignorepkg(alpm_handle_t *handle, const char *pkg)
{
char *vdata = NULL;
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
handle->ignorepkg = alpm_list_remove_str(handle->ignorepkg, pkg, &vdata);
if(vdata != NULL) {
FREE(vdata);
- return(1);
+ return 1;
}
- return(0);
+ return 0;
}
-void SYMEXPORT alpm_option_add_ignoregrp(const char *grp)
+int SYMEXPORT alpm_option_add_ignoregroup(alpm_handle_t *handle, const char *grp)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
- handle->ignoregrp = alpm_list_add(handle->ignoregrp, strdup(grp));
+ CHECK_HANDLE(handle, return -1);
+ handle->ignoregroup = alpm_list_add(handle->ignoregroup, strdup(grp));
+ return 0;
}
-void SYMEXPORT alpm_option_set_ignoregrps(alpm_list_t *ignoregrps)
+int SYMEXPORT alpm_option_set_ignoregroups(alpm_handle_t *handle, alpm_list_t *ignoregrps)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
- if(handle->ignoregrp) FREELIST(handle->ignoregrp);
- if(ignoregrps) handle->ignoregrp = ignoregrps;
+ CHECK_HANDLE(handle, return -1);
+ if(handle->ignoregroup) FREELIST(handle->ignoregroup);
+ handle->ignoregroup = alpm_list_strdup(ignoregrps);
+ return 0;
}
-int SYMEXPORT alpm_option_remove_ignoregrp(const char *grp)
+int SYMEXPORT alpm_option_remove_ignoregroup(alpm_handle_t *handle, const char *grp)
{
char *vdata = NULL;
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
- handle->ignoregrp = alpm_list_remove_str(handle->ignoregrp, grp, &vdata);
+ CHECK_HANDLE(handle, return -1);
+ handle->ignoregroup = alpm_list_remove_str(handle->ignoregroup, grp, &vdata);
if(vdata != NULL) {
FREE(vdata);
- return(1);
+ return 1;
}
- return(0);
+ return 0;
}
-void SYMEXPORT alpm_option_set_arch(const char *arch)
+int SYMEXPORT alpm_option_set_arch(alpm_handle_t *handle, const char *arch)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ CHECK_HANDLE(handle, return -1);
if(handle->arch) FREE(handle->arch);
- if(arch) handle->arch = strdup(arch);
+ if(arch) {
+ handle->arch = strdup(arch);
+ } else {
+ handle->arch = NULL;
+ }
+ return 0;
}
-void SYMEXPORT alpm_option_set_usedelta(int usedelta)
+int SYMEXPORT alpm_option_set_usedelta(alpm_handle_t *handle, int usedelta)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ CHECK_HANDLE(handle, return -1);
handle->usedelta = usedelta;
+ return 0;
}
-void SYMEXPORT alpm_option_set_checkspace(int checkspace)
+int SYMEXPORT alpm_option_set_checkspace(alpm_handle_t *handle, int checkspace)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ CHECK_HANDLE(handle, return -1);
handle->checkspace = checkspace;
+ return 0;
+}
+
+int SYMEXPORT alpm_option_set_default_siglevel(alpm_handle_t *handle,
+ alpm_siglevel_t level)
+{
+ CHECK_HANDLE(handle, return -1);
+#ifdef HAVE_LIBGPGME
+ handle->siglevel = level;
+#else
+ if(level != 0 && level != ALPM_SIG_USE_DEFAULT) {
+ RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1);
+ }
+#endif
+ return 0;
+}
+
+alpm_siglevel_t SYMEXPORT alpm_option_get_default_siglevel(alpm_handle_t *handle)
+{
+ CHECK_HANDLE(handle, return -1);
+ return handle->siglevel;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/handle.h b/lib/libalpm/handle.h
index 2d962fe6..9e038581 100644
--- a/lib/libalpm/handle.h
+++ b/lib/libalpm/handle.h
@@ -24,18 +24,25 @@
#include <sys/types.h>
#include "alpm_list.h"
-#include "db.h"
-#include "log.h"
#include "alpm.h"
-#include "trans.h"
-typedef struct _pmhandle_t {
+#ifdef HAVE_LIBCURL
+#include <curl/curl.h>
+#endif
+
+struct __alpm_handle_t {
/* internal usage */
- pmdb_t *db_local; /* local db pointer */
- alpm_list_t *dbs_sync; /* List of (pmdb_t *) */
+ alpm_db_t *db_local; /* local db pointer */
+ alpm_list_t *dbs_sync; /* List of (alpm_db_t *) */
FILE *logstream; /* log file stream pointer */
FILE *lckstream; /* lock file stream pointer if one exists */
- pmtrans_t *trans;
+ alpm_trans_t *trans;
+
+#ifdef HAVE_LIBCURL
+ /* libcurl handle */
+ CURL *curl; /* reusable curl_easy handle */
+ CURLcode curlerr; /* last error produced by curl */
+#endif
/* callback functions */
alpm_cb_log logcb; /* Log callback function */
@@ -48,26 +55,34 @@ typedef struct _pmhandle_t {
char *dbpath; /* Base path to pacman's DBs */
char *logfile; /* Name of the log file */
char *lockfile; /* Name of the lock file */
+ char *gpgdir; /* Directory where GnuPG files are stored */
alpm_list_t *cachedirs; /* Paths to pacman cache directories */
/* package lists */
alpm_list_t *noupgrade; /* List of packages NOT to be upgraded */
alpm_list_t *noextract; /* List of files NOT to extract */
alpm_list_t *ignorepkg; /* List of packages to ignore */
- alpm_list_t *ignoregrp; /* List of groups to ignore */
+ alpm_list_t *ignoregroup; /* List of groups to ignore */
/* options */
- int usesyslog; /* Use syslog instead of logfile? */ /* TODO move to frontend */
- char *arch; /* Architecture of packages we should allow */
- int usedelta; /* Download deltas if possible */
- int checkspace; /* Check disk space before installing */
-} pmhandle_t;
+ int usesyslog; /* Use syslog instead of logfile? */ /* TODO move to frontend */
+ char *arch; /* Architecture of packages we should allow */
+ int usedelta; /* Download deltas if possible */
+ int checkspace; /* Check disk space before installing */
+ alpm_siglevel_t siglevel; /* Default signature verification level */
+
+ /* error code */
+ enum _alpm_errno_t pm_errno;
+};
+
+alpm_handle_t *_alpm_handle_new(void);
+void _alpm_handle_free(alpm_handle_t *handle);
-/* global handle variable */
-extern pmhandle_t *handle;
+int _alpm_handle_lock(alpm_handle_t *handle);
+int _alpm_handle_unlock(alpm_handle_t *handle);
-pmhandle_t *_alpm_handle_new(void);
-void _alpm_handle_free(pmhandle_t *handle);
+enum _alpm_errno_t _alpm_set_directory_option(const char *value,
+ char **storage, int must_exist);
#endif /* _ALPM_HANDLE_H */
diff --git a/lib/libalpm/log.c b/lib/libalpm/log.c
index 09c6fb84..692ff79c 100644
--- a/lib/libalpm/log.c
+++ b/lib/libalpm/log.c
@@ -22,10 +22,7 @@
#include <stdio.h>
#include <stdarg.h>
-#include <sys/types.h>
-#include <sys/stat.h>
#include <errno.h>
-#include <time.h>
/* libalpm */
#include "log.h"
@@ -39,18 +36,16 @@
*/
/** A printf-like function for logging.
+ * @param handle the context handle
* @param fmt output format
* @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
-int SYMEXPORT alpm_logaction(const char *fmt, ...)
+int SYMEXPORT alpm_logaction(alpm_handle_t *handle, const char *fmt, ...)
{
int ret;
va_list args;
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ ASSERT(handle != NULL, return -1);
/* check if the logstream is open already, opening it if needed */
if(handle->logstream == NULL) {
@@ -58,18 +53,18 @@ int SYMEXPORT alpm_logaction(const char *fmt, ...)
/* if we couldn't open it, we have an issue */
if(handle->logstream == NULL) {
if(errno == EACCES) {
- pm_errno = PM_ERR_BADPERMS;
+ handle->pm_errno = ALPM_ERR_BADPERMS;
} else if(errno == ENOENT) {
- pm_errno = PM_ERR_NOT_A_DIR;
+ handle->pm_errno = ALPM_ERR_NOT_A_DIR;
} else {
- pm_errno = PM_ERR_SYSTEM;
+ handle->pm_errno = ALPM_ERR_SYSTEM;
}
- return(-1);
+ return -1;
}
}
va_start(args, fmt);
- ret = _alpm_logaction(handle->usesyslog, handle->logstream, fmt, args);
+ ret = _alpm_logaction(handle, fmt, args);
va_end(args);
/* TODO We should add a prefix to log strings depending on who called us.
@@ -83,22 +78,21 @@ int SYMEXPORT alpm_logaction(const char *fmt, ...)
* kpacman: "KPACMAN"
* This would allow us to share the log file between several frontends
* and know who does what */
- return(ret);
+ return ret;
}
/** @} */
-void _alpm_log(pmloglevel_t flag, const char *fmt, ...)
+void _alpm_log(alpm_handle_t *handle, alpm_loglevel_t flag, const char *fmt, ...)
{
va_list args;
- alpm_cb_log logcb = alpm_option_get_logcb();
- if(logcb == NULL) {
+ if(handle == NULL || handle->logcb == NULL) {
return;
}
va_start(args, fmt);
- logcb(flag, fmt, args);
+ handle->logcb(flag, fmt, args);
va_end(args);
}
diff --git a/lib/libalpm/log.h b/lib/libalpm/log.h
index 9a2961fb..a43290d8 100644
--- a/lib/libalpm/log.h
+++ b/lib/libalpm/log.h
@@ -22,14 +22,8 @@
#include "alpm.h"
-#ifdef PACMAN_DEBUG
-/* Log funtion entry points if debugging is enabled */
-#define ALPM_LOG_FUNC _alpm_log(PM_LOG_FUNCTION, "Enter %s\n", __func__)
-#else
-#define ALPM_LOG_FUNC
-#endif
-
-void _alpm_log(pmloglevel_t flag, const char *fmt, ...) __attribute__((format(printf,2,3)));
+void _alpm_log(alpm_handle_t *handle, alpm_loglevel_t flag,
+ const char *fmt, ...) __attribute__((format(printf,3,4)));
#endif /* _ALPM_LOG_H */
diff --git a/lib/libalpm/package.c b/lib/libalpm/package.c
index f2f15af4..fd3d0c65 100644
--- a/lib/libalpm/package.c
+++ b/lib/libalpm/package.c
@@ -23,13 +23,9 @@
#include "config.h"
-#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <ctype.h>
-#include <errno.h>
#include <sys/types.h>
-#include <sys/stat.h>
/* libalpm */
#include "package.h"
@@ -47,87 +43,96 @@
*/
/** Free a package. */
-int SYMEXPORT alpm_pkg_free(pmpkg_t *pkg)
+int SYMEXPORT alpm_pkg_free(alpm_pkg_t *pkg)
{
- ALPM_LOG_FUNC;
-
- ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
+ ASSERT(pkg != NULL, return -1);
/* Only free packages loaded in user space */
if(pkg->origin == PKG_FROM_FILE) {
_alpm_pkg_free(pkg);
}
- return(0);
+ return 0;
}
/** Check the integrity (with md5) of a package from the sync cache. */
-int SYMEXPORT alpm_pkg_checkmd5sum(pmpkg_t *pkg)
+int SYMEXPORT alpm_pkg_checkmd5sum(alpm_pkg_t *pkg)
{
char *fpath;
int retval;
- ALPM_LOG_FUNC;
-
- ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
+ ASSERT(pkg != NULL, return -1);
+ pkg->handle->pm_errno = 0;
/* We only inspect packages from sync repositories */
- ASSERT(pkg->origin == PKG_FROM_SYNCDB, RET_ERR(PM_ERR_PKG_INVALID, -1));
+ ASSERT(pkg->origin == PKG_FROM_SYNCDB,
+ RET_ERR(pkg->handle, ALPM_ERR_WRONG_ARGS, -1));
- fpath = _alpm_filecache_find(alpm_pkg_get_filename(pkg));
+ fpath = _alpm_filecache_find(pkg->handle, alpm_pkg_get_filename(pkg));
retval = _alpm_test_md5sum(fpath, alpm_pkg_get_md5sum(pkg));
if(retval == 0) {
- return(0);
- } else if (retval == 1) {
- pm_errno = PM_ERR_PKG_INVALID;
+ return 0;
+ } else if(retval == 1) {
+ pkg->handle->pm_errno = ALPM_ERR_PKG_INVALID;
retval = -1;
}
- return(retval);
+ return retval;
}
/* Default package accessor functions. These will get overridden by any
* backend logic that needs lazy access, such as the local database through
* a lazy-load cache. However, the defaults will work just fine for fully-
* populated package structures. */
-static const char *_pkg_get_filename(pmpkg_t *pkg) { return pkg->filename; }
-static const char *_pkg_get_name(pmpkg_t *pkg) { return pkg->name; }
-static const char *_pkg_get_version(pmpkg_t *pkg) { return pkg->version; }
-static const char *_pkg_get_desc(pmpkg_t *pkg) { return pkg->desc; }
-static const char *_pkg_get_url(pmpkg_t *pkg) { return pkg->url; }
-static time_t _pkg_get_builddate(pmpkg_t *pkg) { return pkg->builddate; }
-static time_t _pkg_get_installdate(pmpkg_t *pkg) { return pkg->installdate; }
-static const char *_pkg_get_packager(pmpkg_t *pkg) { return pkg->packager; }
-static const char *_pkg_get_md5sum(pmpkg_t *pkg) { return pkg->md5sum; }
-static const char *_pkg_get_arch(pmpkg_t *pkg) { return pkg->arch; }
-static off_t _pkg_get_size(pmpkg_t *pkg) { return pkg->size; }
-static off_t _pkg_get_isize(pmpkg_t *pkg) { return pkg->isize; }
-static pmpkgreason_t _pkg_get_reason(pmpkg_t *pkg) { return pkg->reason; }
-static int _pkg_has_scriptlet(pmpkg_t *pkg) { return pkg->scriptlet; }
-
-static alpm_list_t *_pkg_get_licenses(pmpkg_t *pkg) { return pkg->licenses; }
-static alpm_list_t *_pkg_get_groups(pmpkg_t *pkg) { return pkg->groups; }
-static alpm_list_t *_pkg_get_depends(pmpkg_t *pkg) { return pkg->depends; }
-static alpm_list_t *_pkg_get_optdepends(pmpkg_t *pkg) { return pkg->optdepends; }
-static alpm_list_t *_pkg_get_conflicts(pmpkg_t *pkg) { return pkg->conflicts; }
-static alpm_list_t *_pkg_get_provides(pmpkg_t *pkg) { return pkg->provides; }
-static alpm_list_t *_pkg_get_replaces(pmpkg_t *pkg) { return pkg->replaces; }
-static alpm_list_t *_pkg_get_deltas(pmpkg_t *pkg) { return pkg->deltas; }
-static alpm_list_t *_pkg_get_files(pmpkg_t *pkg) { return pkg->files; }
-static alpm_list_t *_pkg_get_backup(pmpkg_t *pkg) { return pkg->backup; }
-
-static void *_pkg_changelog_open(pmpkg_t *pkg) { return NULL; }
-static size_t _pkg_changelog_read(void *ptr, size_t size, const pmpkg_t *pkg, const void *fp) { return 0; }
-static int _pkg_changelog_close(const pmpkg_t *pkg, void *fp) { return EOF; }
+static const char *_pkg_get_filename(alpm_pkg_t *pkg) { return pkg->filename; }
+static const char *_pkg_get_desc(alpm_pkg_t *pkg) { return pkg->desc; }
+static const char *_pkg_get_url(alpm_pkg_t *pkg) { return pkg->url; }
+static time_t _pkg_get_builddate(alpm_pkg_t *pkg) { return pkg->builddate; }
+static time_t _pkg_get_installdate(alpm_pkg_t *pkg) { return pkg->installdate; }
+static const char *_pkg_get_packager(alpm_pkg_t *pkg) { return pkg->packager; }
+static const char *_pkg_get_md5sum(alpm_pkg_t *pkg) { return pkg->md5sum; }
+static const char *_pkg_get_arch(alpm_pkg_t *pkg) { return pkg->arch; }
+static off_t _pkg_get_size(alpm_pkg_t *pkg) { return pkg->size; }
+static off_t _pkg_get_isize(alpm_pkg_t *pkg) { return pkg->isize; }
+static alpm_pkgreason_t _pkg_get_reason(alpm_pkg_t *pkg) { return pkg->reason; }
+static int _pkg_has_scriptlet(alpm_pkg_t *pkg) { return pkg->scriptlet; }
+
+static alpm_list_t *_pkg_get_licenses(alpm_pkg_t *pkg) { return pkg->licenses; }
+static alpm_list_t *_pkg_get_groups(alpm_pkg_t *pkg) { return pkg->groups; }
+static alpm_list_t *_pkg_get_depends(alpm_pkg_t *pkg) { return pkg->depends; }
+static alpm_list_t *_pkg_get_optdepends(alpm_pkg_t *pkg) { return pkg->optdepends; }
+static alpm_list_t *_pkg_get_conflicts(alpm_pkg_t *pkg) { return pkg->conflicts; }
+static alpm_list_t *_pkg_get_provides(alpm_pkg_t *pkg) { return pkg->provides; }
+static alpm_list_t *_pkg_get_replaces(alpm_pkg_t *pkg) { return pkg->replaces; }
+static alpm_list_t *_pkg_get_deltas(alpm_pkg_t *pkg) { return pkg->deltas; }
+static alpm_filelist_t *_pkg_get_files(alpm_pkg_t *pkg) { return &(pkg->files); }
+static alpm_list_t *_pkg_get_backup(alpm_pkg_t *pkg) { return pkg->backup; }
+
+static void *_pkg_changelog_open(alpm_pkg_t UNUSED *pkg)
+{
+ return NULL;
+}
+
+static size_t _pkg_changelog_read(void UNUSED *ptr, size_t UNUSED size,
+ const alpm_pkg_t UNUSED *pkg, const UNUSED void *fp)
+{
+ return 0;
+}
+
+static int _pkg_changelog_close(const alpm_pkg_t UNUSED *pkg,
+ void UNUSED *fp)
+{
+ return EOF;
+}
+
+static int _pkg_force_load(alpm_pkg_t UNUSED *pkg) { return 0; }
/** The standard package operations struct. Get fields directly from the
* struct itself with no abstraction layer or any type of lazy loading.
*/
struct pkg_operations default_pkg_ops = {
.get_filename = _pkg_get_filename,
- .get_name = _pkg_get_name,
- .get_version = _pkg_get_version,
.get_desc = _pkg_get_desc,
.get_url = _pkg_get_url,
.get_builddate = _pkg_get_builddate,
@@ -154,174 +159,233 @@ struct pkg_operations default_pkg_ops = {
.changelog_open = _pkg_changelog_open,
.changelog_read = _pkg_changelog_read,
.changelog_close = _pkg_changelog_close,
+
+ .force_load = _pkg_force_load,
};
/* Public functions for getting package information. These functions
* delegate the hard work to the function callbacks attached to each
* package, which depend on where the package was loaded from. */
-const char SYMEXPORT *alpm_pkg_get_filename(pmpkg_t *pkg)
+const char SYMEXPORT *alpm_pkg_get_filename(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_filename(pkg);
}
-const char SYMEXPORT *alpm_pkg_get_name(pmpkg_t *pkg)
+const char SYMEXPORT *alpm_pkg_get_name(alpm_pkg_t *pkg)
{
- return pkg->ops->get_name(pkg);
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
+ return pkg->name;
}
-const char SYMEXPORT *alpm_pkg_get_version(pmpkg_t *pkg)
+const char SYMEXPORT *alpm_pkg_get_version(alpm_pkg_t *pkg)
{
- return pkg->ops->get_version(pkg);
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
+ return pkg->version;
}
-const char SYMEXPORT *alpm_pkg_get_desc(pmpkg_t *pkg)
+const char SYMEXPORT *alpm_pkg_get_desc(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_desc(pkg);
}
-const char SYMEXPORT *alpm_pkg_get_url(pmpkg_t *pkg)
+const char SYMEXPORT *alpm_pkg_get_url(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_url(pkg);
}
-time_t SYMEXPORT alpm_pkg_get_builddate(pmpkg_t *pkg)
+time_t SYMEXPORT alpm_pkg_get_builddate(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return -1);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_builddate(pkg);
}
-time_t SYMEXPORT alpm_pkg_get_installdate(pmpkg_t *pkg)
+time_t SYMEXPORT alpm_pkg_get_installdate(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return -1);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_installdate(pkg);
}
-const char SYMEXPORT *alpm_pkg_get_packager(pmpkg_t *pkg)
+const char SYMEXPORT *alpm_pkg_get_packager(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_packager(pkg);
}
-const char SYMEXPORT *alpm_pkg_get_md5sum(pmpkg_t *pkg)
+const char SYMEXPORT *alpm_pkg_get_md5sum(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_md5sum(pkg);
}
-const char SYMEXPORT *alpm_pkg_get_arch(pmpkg_t *pkg)
+const char SYMEXPORT *alpm_pkg_get_arch(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_arch(pkg);
}
-off_t SYMEXPORT alpm_pkg_get_size(pmpkg_t *pkg)
+off_t SYMEXPORT alpm_pkg_get_size(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return -1);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_size(pkg);
}
-off_t SYMEXPORT alpm_pkg_get_isize(pmpkg_t *pkg)
+off_t SYMEXPORT alpm_pkg_get_isize(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return -1);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_isize(pkg);
}
-pmpkgreason_t SYMEXPORT alpm_pkg_get_reason(pmpkg_t *pkg)
+alpm_pkgreason_t SYMEXPORT alpm_pkg_get_reason(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return -1);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_reason(pkg);
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_licenses(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_get_licenses(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_licenses(pkg);
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_groups(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_get_groups(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_groups(pkg);
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_depends(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_get_depends(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_depends(pkg);
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_optdepends(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_get_optdepends(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_optdepends(pkg);
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_conflicts(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_get_conflicts(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_conflicts(pkg);
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_provides(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_get_provides(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_provides(pkg);
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_replaces(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_get_replaces(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_replaces(pkg);
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_deltas(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_get_deltas(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_deltas(pkg);
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_files(pmpkg_t *pkg)
+alpm_filelist_t SYMEXPORT *alpm_pkg_get_files(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_files(pkg);
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_backup(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_get_backup(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->get_backup(pkg);
}
-pmdb_t SYMEXPORT *alpm_pkg_get_db(pmpkg_t *pkg)
+alpm_db_t SYMEXPORT *alpm_pkg_get_db(alpm_pkg_t *pkg)
{
/* Sanity checks */
- ASSERT(pkg != NULL, return(NULL));
- ASSERT(pkg->origin != PKG_FROM_FILE, return(NULL));
+ ASSERT(pkg != NULL, return NULL);
+ ASSERT(pkg->origin != PKG_FROM_FILE, return NULL);
+ pkg->handle->pm_errno = 0;
- return(pkg->origin_data.db);
+ return pkg->origin_data.db;
}
/** Open a package changelog for reading. */
-void SYMEXPORT *alpm_pkg_changelog_open(pmpkg_t *pkg)
+void SYMEXPORT *alpm_pkg_changelog_open(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
return pkg->ops->changelog_open(pkg);
}
/** Read data from an open changelog 'file stream'. */
size_t SYMEXPORT alpm_pkg_changelog_read(void *ptr, size_t size,
- const pmpkg_t *pkg, const void *fp)
+ const alpm_pkg_t *pkg, const void *fp)
{
+ ASSERT(pkg != NULL, return 0);
+ pkg->handle->pm_errno = 0;
return pkg->ops->changelog_read(ptr, size, pkg, fp);
}
/*
-int SYMEXPORT alpm_pkg_changelog_feof(const pmpkg_t *pkg, void *fp)
+int SYMEXPORT alpm_pkg_changelog_feof(const alpm_pkg_t *pkg, void *fp)
{
return pkg->ops->changelog_feof(pkg, fp);
}
*/
/** Close a package changelog for reading. */
-int SYMEXPORT alpm_pkg_changelog_close(const pmpkg_t *pkg, void *fp)
+int SYMEXPORT alpm_pkg_changelog_close(const alpm_pkg_t *pkg, void *fp)
{
+ ASSERT(pkg != NULL, return -1);
+ pkg->handle->pm_errno = 0;
return pkg->ops->changelog_close(pkg, fp);
}
-int SYMEXPORT alpm_pkg_has_scriptlet(pmpkg_t *pkg)
+int SYMEXPORT alpm_pkg_has_scriptlet(alpm_pkg_t *pkg)
{
+ ASSERT(pkg != NULL, return -1);
+ pkg->handle->pm_errno = 0;
return pkg->ops->has_scriptlet(pkg);
}
-static void find_requiredby(pmpkg_t *pkg, pmdb_t *db, alpm_list_t **reqs)
+static void find_requiredby(alpm_pkg_t *pkg, alpm_db_t *db, alpm_list_t **reqs)
{
const alpm_list_t *i;
+ pkg->handle->pm_errno = 0;
+
for(i = _alpm_db_get_pkgcache(db); i; i = i->next) {
- pmpkg_t *cachepkg = i->data;
- alpm_list_t *i;
- for(i = alpm_pkg_get_depends(cachepkg); i; i = i->next) {
- if(_alpm_depcmp(pkg, i->data)) {
+ alpm_pkg_t *cachepkg = i->data;
+ alpm_list_t *j;
+ for(j = alpm_pkg_get_depends(cachepkg); j; j = j->next) {
+ if(_alpm_depcmp(pkg, j->data)) {
const char *cachepkgname = cachepkg->name;
if(alpm_list_find_str(*reqs, cachepkgname) == NULL) {
*reqs = alpm_list_add(*reqs, strdup(cachepkgname));
@@ -332,16 +396,18 @@ static void find_requiredby(pmpkg_t *pkg, pmdb_t *db, alpm_list_t **reqs)
}
/** Compute the packages requiring a given package. */
-alpm_list_t SYMEXPORT *alpm_pkg_compute_requiredby(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_compute_requiredby(alpm_pkg_t *pkg)
{
const alpm_list_t *i;
alpm_list_t *reqs = NULL;
- pmdb_t *db;
+ alpm_db_t *db;
+
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
if(pkg->origin == PKG_FROM_FILE) {
/* The sane option; search locally for things that require this. */
- db = alpm_option_get_localdb();
- find_requiredby(pkg, db, &reqs);
+ find_requiredby(pkg, pkg->handle->db_local, &reqs);
} else {
/* We have a DB package. if it is a local package, then we should
* only search the local DB; else search all known sync databases. */
@@ -349,49 +415,68 @@ alpm_list_t SYMEXPORT *alpm_pkg_compute_requiredby(pmpkg_t *pkg)
if(db->is_local) {
find_requiredby(pkg, db, &reqs);
} else {
- for(i = handle->dbs_sync; i; i = i->next) {
+ for(i = pkg->handle->dbs_sync; i; i = i->next) {
db = i->data;
find_requiredby(pkg, db, &reqs);
}
reqs = alpm_list_msort(reqs, alpm_list_count(reqs), _alpm_str_cmp);
}
}
- return(reqs);
+ return reqs;
}
/** @} */
-pmpkg_t *_alpm_pkg_new(void)
+alpm_file_t *_alpm_file_copy(alpm_file_t *dest,
+ const alpm_file_t *src)
+{
+ STRDUP(dest->name, src->name, return NULL);
+ dest->size = src->size;
+ dest->mode = src->mode;
+
+ return dest;
+}
+
+/* Helper function for comparing files list entries
+ */
+int _alpm_files_cmp(const void *f1, const void *f2)
{
- pmpkg_t* pkg;
+ const alpm_file_t *file1 = f1;
+ const alpm_file_t *file2 = f2;
+ return strcmp(file1->name, file2->name);
+}
- ALPM_LOG_FUNC;
+alpm_pkg_t *_alpm_pkg_new(void)
+{
+ alpm_pkg_t* pkg;
- CALLOC(pkg, 1, sizeof(pmpkg_t), RET_ERR(PM_ERR_MEMORY, NULL));
+ CALLOC(pkg, 1, sizeof(alpm_pkg_t), return NULL);
- return(pkg);
+ return pkg;
}
-pmpkg_t *_alpm_pkg_dup(pmpkg_t *pkg)
+alpm_pkg_t *_alpm_pkg_dup(alpm_pkg_t *pkg)
{
- pmpkg_t *newpkg;
+ alpm_pkg_t *newpkg;
alpm_list_t *i;
- ALPM_LOG_FUNC;
+ if(pkg->ops->force_load(pkg)) {
+ return NULL;
+ }
- CALLOC(newpkg, 1, sizeof(pmpkg_t), RET_ERR(PM_ERR_MEMORY, NULL));
+ CALLOC(newpkg, 1, sizeof(alpm_pkg_t), goto cleanup);
newpkg->name_hash = pkg->name_hash;
- STRDUP(newpkg->filename, pkg->filename, RET_ERR(PM_ERR_MEMORY, newpkg));
- STRDUP(newpkg->name, pkg->name, RET_ERR(PM_ERR_MEMORY, newpkg));
- STRDUP(newpkg->version, pkg->version, RET_ERR(PM_ERR_MEMORY, newpkg));
- STRDUP(newpkg->desc, pkg->desc, RET_ERR(PM_ERR_MEMORY, newpkg));
- STRDUP(newpkg->url, pkg->url, RET_ERR(PM_ERR_MEMORY, newpkg));
+ STRDUP(newpkg->filename, pkg->filename, goto cleanup);
+ STRDUP(newpkg->name, pkg->name, goto cleanup);
+ STRDUP(newpkg->version, pkg->version, goto cleanup);
+ STRDUP(newpkg->desc, pkg->desc, goto cleanup);
+ STRDUP(newpkg->url, pkg->url, goto cleanup);
newpkg->builddate = pkg->builddate;
newpkg->installdate = pkg->installdate;
- STRDUP(newpkg->packager, pkg->packager, RET_ERR(PM_ERR_MEMORY, newpkg));
- STRDUP(newpkg->md5sum, pkg->md5sum, RET_ERR(PM_ERR_MEMORY, newpkg));
- STRDUP(newpkg->arch, pkg->arch, RET_ERR(PM_ERR_MEMORY, newpkg));
+ STRDUP(newpkg->packager, pkg->packager, goto cleanup);
+ STRDUP(newpkg->md5sum, pkg->md5sum, goto cleanup);
+ STRDUP(newpkg->arch, pkg->arch, goto cleanup);
newpkg->size = pkg->size;
newpkg->isize = pkg->isize;
newpkg->scriptlet = pkg->scriptlet;
@@ -400,33 +485,51 @@ pmpkg_t *_alpm_pkg_dup(pmpkg_t *pkg)
newpkg->licenses = alpm_list_strdup(pkg->licenses);
newpkg->replaces = alpm_list_strdup(pkg->replaces);
newpkg->groups = alpm_list_strdup(pkg->groups);
- newpkg->files = alpm_list_strdup(pkg->files);
- newpkg->backup = alpm_list_strdup(pkg->backup);
+ if(pkg->files.count) {
+ size_t filenum;
+ size_t len = sizeof(alpm_file_t) * pkg->files.count;
+ MALLOC(newpkg->files.files, len, goto cleanup);
+ for(filenum = 0; filenum < pkg->files.count; filenum++) {
+ if(!_alpm_file_copy(newpkg->files.files + filenum,
+ pkg->files.files + filenum)) {
+ goto cleanup;
+ }
+ }
+ newpkg->files.count = pkg->files.count;
+ }
+ for(i = pkg->backup; i; i = alpm_list_next(i)) {
+ newpkg->backup = alpm_list_add(newpkg->backup, _alpm_backup_dup(i->data));
+ }
for(i = pkg->depends; i; i = alpm_list_next(i)) {
newpkg->depends = alpm_list_add(newpkg->depends, _alpm_dep_dup(i->data));
}
newpkg->optdepends = alpm_list_strdup(pkg->optdepends);
newpkg->conflicts = alpm_list_strdup(pkg->conflicts);
newpkg->provides = alpm_list_strdup(pkg->provides);
- newpkg->deltas = alpm_list_copy_data(pkg->deltas, sizeof(pmdelta_t));
+ for(i = pkg->deltas; i; i = alpm_list_next(i)) {
+ newpkg->deltas = alpm_list_add(newpkg->deltas, _alpm_delta_dup(i->data));
+ }
/* internal */
+ newpkg->infolevel = pkg->infolevel;
newpkg->origin = pkg->origin;
- newpkg->ops = pkg->ops;
if(newpkg->origin == PKG_FROM_FILE) {
newpkg->origin_data.file = strdup(pkg->origin_data.file);
} else {
newpkg->origin_data.db = pkg->origin_data.db;
}
- newpkg->infolevel = pkg->infolevel;
+ newpkg->ops = pkg->ops;
+ newpkg->handle = pkg->handle;
- return(newpkg);
+ return newpkg;
+
+cleanup:
+ _alpm_pkg_free(newpkg);
+ return NULL;
}
-void _alpm_pkg_free(pmpkg_t *pkg)
+void _alpm_pkg_free(alpm_pkg_t *pkg)
{
- ALPM_LOG_FUNC;
-
if(pkg == NULL) {
return;
}
@@ -438,12 +541,20 @@ void _alpm_pkg_free(pmpkg_t *pkg)
FREE(pkg->url);
FREE(pkg->packager);
FREE(pkg->md5sum);
+ FREE(pkg->base64_sig);
FREE(pkg->arch);
FREELIST(pkg->licenses);
FREELIST(pkg->replaces);
FREELIST(pkg->groups);
- FREELIST(pkg->files);
- FREELIST(pkg->backup);
+ if(pkg->files.count) {
+ size_t i;
+ for(i = 0; i < pkg->files.count; i++) {
+ free(pkg->files.files[i].name);
+ }
+ free(pkg->files.files);
+ }
+ alpm_list_free_inner(pkg->backup, (alpm_list_fn_free)_alpm_backup_free);
+ alpm_list_free(pkg->backup);
alpm_list_free_inner(pkg->depends, (alpm_list_fn_free)_alpm_dep_free);
alpm_list_free(pkg->depends);
FREELIST(pkg->optdepends);
@@ -465,10 +576,8 @@ void _alpm_pkg_free(pmpkg_t *pkg)
* Case 2: If pkg is a pkgcache entry (PKG_FROM_CACHE), it won't be freed,
* only the transaction specific fields of pkg will be freed.
*/
-void _alpm_pkg_free_trans(pmpkg_t *pkg)
+void _alpm_pkg_free_trans(alpm_pkg_t *pkg)
{
- ALPM_LOG_FUNC;
-
if(pkg == NULL) {
return;
}
@@ -483,10 +592,8 @@ void _alpm_pkg_free_trans(pmpkg_t *pkg)
}
/* Is spkg an upgrade for localpkg? */
-int _alpm_pkg_compare_versions(pmpkg_t *spkg, pmpkg_t *localpkg)
+int _alpm_pkg_compare_versions(alpm_pkg_t *spkg, alpm_pkg_t *localpkg)
{
- ALPM_LOG_FUNC;
-
return alpm_pkg_vercmp(alpm_pkg_get_version(spkg),
alpm_pkg_get_version(localpkg));
}
@@ -495,29 +602,27 @@ int _alpm_pkg_compare_versions(pmpkg_t *spkg, pmpkg_t *localpkg)
*/
int _alpm_pkg_cmp(const void *p1, const void *p2)
{
- pmpkg_t *pkg1 = (pmpkg_t *)p1;
- pmpkg_t *pkg2 = (pmpkg_t *)p2;
- return(strcoll(pkg1->name, pkg2->name));
+ const alpm_pkg_t *pkg1 = p1;
+ const alpm_pkg_t *pkg2 = p2;
+ return strcoll(pkg1->name, pkg2->name);
}
/* Test for existence of a package in a alpm_list_t*
- * of pmpkg_t*
+ * of alpm_pkg_t*
*/
-pmpkg_t *_alpm_pkg_find(alpm_list_t *haystack, const char *needle)
+alpm_pkg_t *_alpm_pkg_find(alpm_list_t *haystack, const char *needle)
{
alpm_list_t *lp;
unsigned long needle_hash;
- ALPM_LOG_FUNC;
-
if(needle == NULL || haystack == NULL) {
- return(NULL);
+ return NULL;
}
needle_hash = _alpm_hash_sdbm(needle);
for(lp = haystack; lp; lp = lp->next) {
- pmpkg_t *info = lp->data;
+ alpm_pkg_t *info = lp->data;
if(info) {
/* a zero hash will cause a fall-through just in case */
@@ -527,40 +632,41 @@ pmpkg_t *_alpm_pkg_find(alpm_list_t *haystack, const char *needle)
/* finally: we had hash match, verify string match */
if(strcmp(info->name, needle) == 0) {
- return(info);
+ return info;
}
}
}
- return(NULL);
+ return NULL;
}
/** Test if a package should be ignored.
*
* Checks if the package is ignored via IgnorePkg, or if the package is
- * in a group ignored via IgnoreGrp.
+ * in a group ignored via IgnoreGroup.
*
+ * @param handle the context handle
* @param pkg the package to test
*
* @return 1 if the package should be ignored, 0 otherwise
*/
-int _alpm_pkg_should_ignore(pmpkg_t *pkg)
+int _alpm_pkg_should_ignore(alpm_handle_t *handle, alpm_pkg_t *pkg)
{
alpm_list_t *groups = NULL;
/* first see if the package is ignored */
if(alpm_list_find_str(handle->ignorepkg, alpm_pkg_get_name(pkg))) {
- return(1);
+ return 1;
}
/* next see if the package is in a group that is ignored */
- for(groups = handle->ignoregrp; groups; groups = alpm_list_next(groups)) {
+ for(groups = handle->ignoregroup; groups; groups = alpm_list_next(groups)) {
char *grp = (char *)alpm_list_getdata(groups);
if(alpm_list_find_str(alpm_pkg_get_groups(pkg), grp)) {
- return(1);
+ return 1;
}
}
- return(0);
+ return 0;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/package.h b/lib/libalpm/package.h
index b161d5f1..d19d8332 100644
--- a/lib/libalpm/package.h
+++ b/lib/libalpm/package.h
@@ -24,17 +24,21 @@
#ifndef _ALPM_PACKAGE_H
#define _ALPM_PACKAGE_H
+#include "config.h" /* ensure off_t is correct length */
+
#include <sys/types.h> /* off_t */
#include <time.h> /* time_t */
#include "alpm.h"
+#include "backup.h"
#include "db.h"
+#include "signing.h"
-typedef enum _pmpkgfrom_t {
+typedef enum _alpm_pkgfrom_t {
PKG_FROM_FILE = 1,
PKG_FROM_LOCALDB,
PKG_FROM_SYNCDB
-} pmpkgfrom_t;
+} alpm_pkgfrom_t;
/** Package operations struct. This struct contains function pointers to
* all methods used to access data in a package to allow for things such
@@ -44,35 +48,35 @@ typedef enum _pmpkgfrom_t {
* defined default_pkg_ops struct to work just fine for their needs.
*/
struct pkg_operations {
- const char *(*get_filename) (pmpkg_t *);
- const char *(*get_name) (pmpkg_t *);
- const char *(*get_version) (pmpkg_t *);
- const char *(*get_desc) (pmpkg_t *);
- const char *(*get_url) (pmpkg_t *);
- time_t (*get_builddate) (pmpkg_t *);
- time_t (*get_installdate) (pmpkg_t *);
- const char *(*get_packager) (pmpkg_t *);
- const char *(*get_md5sum) (pmpkg_t *);
- const char *(*get_arch) (pmpkg_t *);
- off_t (*get_size) (pmpkg_t *);
- off_t (*get_isize) (pmpkg_t *);
- pmpkgreason_t (*get_reason) (pmpkg_t *);
- int (*has_scriptlet) (pmpkg_t *);
-
- alpm_list_t *(*get_licenses) (pmpkg_t *);
- alpm_list_t *(*get_groups) (pmpkg_t *);
- alpm_list_t *(*get_depends) (pmpkg_t *);
- alpm_list_t *(*get_optdepends) (pmpkg_t *);
- alpm_list_t *(*get_conflicts) (pmpkg_t *);
- alpm_list_t *(*get_provides) (pmpkg_t *);
- alpm_list_t *(*get_replaces) (pmpkg_t *);
- alpm_list_t *(*get_deltas) (pmpkg_t *);
- alpm_list_t *(*get_files) (pmpkg_t *);
- alpm_list_t *(*get_backup) (pmpkg_t *);
-
- void *(*changelog_open) (pmpkg_t *);
- size_t (*changelog_read) (void *, size_t, const pmpkg_t *, const void *);
- int (*changelog_close) (const pmpkg_t *, void *);
+ const char *(*get_filename) (alpm_pkg_t *);
+ const char *(*get_desc) (alpm_pkg_t *);
+ const char *(*get_url) (alpm_pkg_t *);
+ time_t (*get_builddate) (alpm_pkg_t *);
+ time_t (*get_installdate) (alpm_pkg_t *);
+ const char *(*get_packager) (alpm_pkg_t *);
+ const char *(*get_md5sum) (alpm_pkg_t *);
+ const char *(*get_arch) (alpm_pkg_t *);
+ off_t (*get_size) (alpm_pkg_t *);
+ off_t (*get_isize) (alpm_pkg_t *);
+ alpm_pkgreason_t (*get_reason) (alpm_pkg_t *);
+ int (*has_scriptlet) (alpm_pkg_t *);
+
+ alpm_list_t *(*get_licenses) (alpm_pkg_t *);
+ alpm_list_t *(*get_groups) (alpm_pkg_t *);
+ alpm_list_t *(*get_depends) (alpm_pkg_t *);
+ alpm_list_t *(*get_optdepends) (alpm_pkg_t *);
+ alpm_list_t *(*get_conflicts) (alpm_pkg_t *);
+ alpm_list_t *(*get_provides) (alpm_pkg_t *);
+ alpm_list_t *(*get_replaces) (alpm_pkg_t *);
+ alpm_list_t *(*get_deltas) (alpm_pkg_t *);
+ alpm_filelist_t *(*get_files) (alpm_pkg_t *);
+ alpm_list_t *(*get_backup) (alpm_pkg_t *);
+
+ void *(*changelog_open) (alpm_pkg_t *);
+ size_t (*changelog_read) (void *, size_t, const alpm_pkg_t *, const void *);
+ int (*changelog_close) (const alpm_pkg_t *, void *);
+
+ int (*force_load) (alpm_pkg_t *);
/* still to add:
* checkmd5sum() ?
@@ -87,7 +91,7 @@ struct pkg_operations {
*/
extern struct pkg_operations default_pkg_ops;
-struct __pmpkg_t {
+struct __alpm_pkg_t {
unsigned long name_hash;
char *filename;
char *name;
@@ -96,6 +100,7 @@ struct __pmpkg_t {
char *url;
char *packager;
char *md5sum;
+ char *base64_sig;
char *arch;
time_t builddate;
@@ -107,20 +112,20 @@ struct __pmpkg_t {
int scriptlet;
- pmpkgreason_t reason;
- pmpkgfrom_t origin;
+ alpm_pkgreason_t reason;
+ alpm_dbinfrq_t infolevel;
+ alpm_pkgfrom_t origin;
/* origin == PKG_FROM_FILE, use pkg->origin_data.file
* origin == PKG_FROM_*DB, use pkg->origin_data.db */
union {
- pmdb_t *db;
+ alpm_db_t *db;
char *file;
} origin_data;
- pmdbinfrq_t infolevel;
+ alpm_handle_t *handle;
alpm_list_t *licenses;
alpm_list_t *replaces;
alpm_list_t *groups;
- alpm_list_t *files;
alpm_list_t *backup;
alpm_list_t *depends;
alpm_list_t *optdepends;
@@ -131,16 +136,27 @@ struct __pmpkg_t {
alpm_list_t *removes; /* in transaction targets only */
struct pkg_operations *ops;
+
+ alpm_filelist_t files;
};
-pmpkg_t* _alpm_pkg_new(void);
-pmpkg_t *_alpm_pkg_dup(pmpkg_t *pkg);
-void _alpm_pkg_free(pmpkg_t *pkg);
-void _alpm_pkg_free_trans(pmpkg_t *pkg);
+alpm_file_t *_alpm_file_copy(alpm_file_t *dest, const alpm_file_t *src);
+int _alpm_files_cmp(const void *f1, const void *f2);
+
+alpm_pkg_t* _alpm_pkg_new(void);
+alpm_pkg_t *_alpm_pkg_dup(alpm_pkg_t *pkg);
+void _alpm_pkg_free(alpm_pkg_t *pkg);
+void _alpm_pkg_free_trans(alpm_pkg_t *pkg);
+
+
+alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle, const char *pkgfile,
+ int full, const char *md5sum, const char *base64_sig,
+ alpm_siglevel_t level);
+
int _alpm_pkg_cmp(const void *p1, const void *p2);
-int _alpm_pkg_compare_versions(pmpkg_t *local_pkg, pmpkg_t *pkg);
-pmpkg_t *_alpm_pkg_find(alpm_list_t *haystack, const char *needle);
-int _alpm_pkg_should_ignore(pmpkg_t *pkg);
+int _alpm_pkg_compare_versions(alpm_pkg_t *local_pkg, alpm_pkg_t *pkg);
+alpm_pkg_t *_alpm_pkg_find(alpm_list_t *haystack, const char *needle);
+int _alpm_pkg_should_ignore(alpm_handle_t *handle, alpm_pkg_t *pkg);
#endif /* _ALPM_PACKAGE_H */
diff --git a/lib/libalpm/pkghash.c b/lib/libalpm/pkghash.c
index 6dc43243..f6207ada 100644
--- a/lib/libalpm/pkghash.c
+++ b/lib/libalpm/pkghash.c
@@ -17,9 +17,10 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+#include <errno.h>
+
#include "pkghash.h"
#include "util.h"
-#include "log.h"
/* List of primes for possible sizes of hash tables.
*
@@ -50,16 +51,12 @@ static const size_t prime_list[] =
};
/* Allocate a hash table with at least "size" buckets */
-pmpkghash_t *_alpm_pkghash_create(size_t size)
+alpm_pkghash_t *_alpm_pkghash_create(size_t size)
{
- pmpkghash_t *hash = NULL;
+ alpm_pkghash_t *hash = NULL;
size_t i, loopsize;
- MALLOC(hash, sizeof(pmpkghash_t), RET_ERR(PM_ERR_MEMORY, NULL));
-
- hash->list = NULL;
- hash->entries = 0;
- hash->buckets = 0;
+ CALLOC(hash, 1, sizeof(alpm_pkghash_t), return NULL);
loopsize = sizeof(prime_list) / sizeof(*prime_list);
for(i = 0; i < loopsize; i++) {
@@ -70,18 +67,18 @@ pmpkghash_t *_alpm_pkghash_create(size_t size)
}
if(hash->buckets < size) {
- _alpm_log(PM_LOG_ERROR, _("database larger than maximum size\n"));
+ errno = ERANGE;
free(hash);
- return(NULL);
+ return NULL;
}
- CALLOC(hash->hash_table, hash->buckets, sizeof(alpm_list_t*), \
- free(hash); RET_ERR(PM_ERR_MEMORY, NULL));
+ CALLOC(hash->hash_table, hash->buckets, sizeof(alpm_list_t *), \
+ free(hash); return NULL);
- return(hash);
+ return hash;
}
-static size_t get_hash_position(unsigned long name_hash, pmpkghash_t *hash)
+static size_t get_hash_position(unsigned long name_hash, alpm_pkghash_t *hash)
{
size_t position;
@@ -92,13 +89,13 @@ static size_t get_hash_position(unsigned long name_hash, pmpkghash_t *hash)
position = (position + 1) % hash->buckets;
}
- return(position);
+ return position;
}
/* Expand the hash table size to the next increment and rebin the entries */
-static pmpkghash_t *rehash(pmpkghash_t *oldhash)
+static alpm_pkghash_t *rehash(alpm_pkghash_t *oldhash)
{
- pmpkghash_t *newhash;
+ alpm_pkghash_t *newhash;
size_t newsize, position, i;
/* Hash tables will need resized in two cases:
@@ -123,7 +120,7 @@ static pmpkghash_t *rehash(pmpkghash_t *oldhash)
newhash = _alpm_pkghash_create(newsize);
if(newhash == NULL) {
/* creation of newhash failed, stick with old one... */
- return(oldhash);
+ return oldhash;
}
newhash->list = oldhash->list;
@@ -131,7 +128,7 @@ static pmpkghash_t *rehash(pmpkghash_t *oldhash)
for(i = 0; i < oldhash->buckets; i++) {
if(oldhash->hash_table[i] != NULL) {
- pmpkg_t *package = oldhash->hash_table[i]->data;
+ alpm_pkg_t *package = oldhash->hash_table[i]->data;
position = get_hash_position(package->name_hash, newhash);
@@ -144,16 +141,16 @@ static pmpkghash_t *rehash(pmpkghash_t *oldhash)
_alpm_pkghash_free(oldhash);
- return(newhash);
+ return newhash;
}
-static pmpkghash_t *pkghash_add_pkg(pmpkghash_t *hash, pmpkg_t *pkg, int sorted)
+static alpm_pkghash_t *pkghash_add_pkg(alpm_pkghash_t *hash, alpm_pkg_t *pkg, int sorted)
{
alpm_list_t *ptr;
size_t position;
if(pkg == NULL || hash == NULL) {
- return(hash);
+ return hash;
}
if((hash->entries + 1) / MAX_HASH_LOAD > hash->buckets) {
@@ -164,7 +161,7 @@ static pmpkghash_t *pkghash_add_pkg(pmpkghash_t *hash, pmpkg_t *pkg, int sorted)
ptr = calloc(1, sizeof(alpm_list_t));
if(ptr == NULL) {
- return(hash);
+ return hash;
}
ptr->data = pkg;
@@ -179,20 +176,20 @@ static pmpkghash_t *pkghash_add_pkg(pmpkghash_t *hash, pmpkg_t *pkg, int sorted)
}
hash->entries += 1;
- return(hash);
+ return hash;
}
-pmpkghash_t *_alpm_pkghash_add(pmpkghash_t *hash, pmpkg_t *pkg)
+alpm_pkghash_t *_alpm_pkghash_add(alpm_pkghash_t *hash, alpm_pkg_t *pkg)
{
- return(pkghash_add_pkg(hash, pkg, 0));
+ return pkghash_add_pkg(hash, pkg, 0);
}
-pmpkghash_t *_alpm_pkghash_add_sorted(pmpkghash_t *hash, pmpkg_t *pkg)
+alpm_pkghash_t *_alpm_pkghash_add_sorted(alpm_pkghash_t *hash, alpm_pkg_t *pkg)
{
- return(pkghash_add_pkg(hash, pkg, 1));
+ return pkghash_add_pkg(hash, pkg, 1);
}
-static size_t move_one_entry(pmpkghash_t *hash, size_t start, size_t end)
+static size_t move_one_entry(alpm_pkghash_t *hash, size_t start, size_t end)
{
/* Iterate backwards from 'end' to 'start', seeing if any of the items
* would hash to 'start'. If we find one, we move it there and break. If
@@ -203,7 +200,7 @@ static size_t move_one_entry(pmpkghash_t *hash, size_t start, size_t end)
* 'start' we can stop this madness. */
while(end != start) {
alpm_list_t *i = hash->hash_table[end];
- pmpkg_t *info = i->data;
+ alpm_pkg_t *info = i->data;
size_t new_position = get_hash_position(info->name_hash, hash);
if(new_position == start) {
@@ -217,7 +214,7 @@ static size_t move_one_entry(pmpkghash_t *hash, size_t start, size_t end)
* e.g. (47 + 0 - 1) % 47 == 46 */
end = (hash->buckets + end - 1) % hash->buckets;
}
- return(end);
+ return end;
}
/**
@@ -229,8 +226,8 @@ static size_t move_one_entry(pmpkghash_t *hash, size_t start, size_t end)
*
* @return the resultant hash
*/
-pmpkghash_t *_alpm_pkghash_remove(pmpkghash_t *hash, pmpkg_t *pkg,
- pmpkg_t **data)
+alpm_pkghash_t *_alpm_pkghash_remove(alpm_pkghash_t *hash, alpm_pkg_t *pkg,
+ alpm_pkg_t **data)
{
alpm_list_t *i;
size_t position;
@@ -240,12 +237,12 @@ pmpkghash_t *_alpm_pkghash_remove(pmpkghash_t *hash, pmpkg_t *pkg,
}
if(pkg == NULL || hash == NULL) {
- return(hash);
+ return hash;
}
position = pkg->name_hash % hash->buckets;
while((i = hash->hash_table[position]) != NULL) {
- pmpkg_t *info = i->data;
+ alpm_pkg_t *info = i->data;
if(info->name_hash == pkg->name_hash &&
strcmp(info->name, pkg->name) == 0) {
@@ -277,16 +274,16 @@ pmpkghash_t *_alpm_pkghash_remove(pmpkghash_t *hash, pmpkg_t *pkg,
position = prev;
}
- return(hash);
+ return hash;
}
position = (position + 1) % hash->buckets;
}
- return(hash);
+ return hash;
}
-void _alpm_pkghash_free(pmpkghash_t *hash)
+void _alpm_pkghash_free(alpm_pkghash_t *hash)
{
size_t i;
if(hash != NULL) {
@@ -298,16 +295,14 @@ void _alpm_pkghash_free(pmpkghash_t *hash)
free(hash);
}
-pmpkg_t *_alpm_pkghash_find(pmpkghash_t *hash, const char *name)
+alpm_pkg_t *_alpm_pkghash_find(alpm_pkghash_t *hash, const char *name)
{
alpm_list_t *lp;
unsigned long name_hash;
size_t position;
- ALPM_LOG_FUNC;
-
if(name == NULL || hash == NULL) {
- return(NULL);
+ return NULL;
}
name_hash = _alpm_hash_sdbm(name);
@@ -315,16 +310,16 @@ pmpkg_t *_alpm_pkghash_find(pmpkghash_t *hash, const char *name)
position = name_hash % hash->buckets;
while((lp = hash->hash_table[position]) != NULL) {
- pmpkg_t *info = lp->data;
+ alpm_pkg_t *info = lp->data;
if(info->name_hash == name_hash && strcmp(info->name, name) == 0) {
- return(info);
+ return info;
}
position = (position + 1) % hash->buckets;
}
- return(NULL);
+ return NULL;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/pkghash.h b/lib/libalpm/pkghash.h
index 617e60bd..edd500e9 100644
--- a/lib/libalpm/pkghash.h
+++ b/lib/libalpm/pkghash.h
@@ -27,12 +27,12 @@
/**
- * @brief A hash table for holding pmpkg_t objects.
+ * @brief A hash table for holding alpm_pkg_t objects.
*
* A combination of a hash table and a list, allowing for fast look-up
* by package name but also iteration over the packages.
*/
-struct __pmpkghash_t {
+struct __alpm_pkghash_t {
/** data held by the hash table */
alpm_list_t **hash_table;
/** number of buckets in hash table */
@@ -43,17 +43,17 @@ struct __pmpkghash_t {
alpm_list_t *list;
};
-typedef struct __pmpkghash_t pmpkghash_t;
+typedef struct __alpm_pkghash_t alpm_pkghash_t;
-pmpkghash_t *_alpm_pkghash_create(size_t size);
+alpm_pkghash_t *_alpm_pkghash_create(size_t size);
-pmpkghash_t *_alpm_pkghash_add(pmpkghash_t *hash, pmpkg_t *pkg);
-pmpkghash_t *_alpm_pkghash_add_sorted(pmpkghash_t *hash, pmpkg_t *pkg);
-pmpkghash_t *_alpm_pkghash_remove(pmpkghash_t *hash, pmpkg_t *pkg, pmpkg_t **data);
+alpm_pkghash_t *_alpm_pkghash_add(alpm_pkghash_t *hash, alpm_pkg_t *pkg);
+alpm_pkghash_t *_alpm_pkghash_add_sorted(alpm_pkghash_t *hash, alpm_pkg_t *pkg);
+alpm_pkghash_t *_alpm_pkghash_remove(alpm_pkghash_t *hash, alpm_pkg_t *pkg, alpm_pkg_t **data);
-void _alpm_pkghash_free(pmpkghash_t *hash);
+void _alpm_pkghash_free(alpm_pkghash_t *hash);
-pmpkg_t *_alpm_pkghash_find(pmpkghash_t *hash, const char *name);
+alpm_pkg_t *_alpm_pkghash_find(alpm_pkghash_t *hash, const char *name);
#define MAX_HASH_LOAD 0.7
diff --git a/lib/libalpm/po/Makevars b/lib/libalpm/po/Makevars
index 688553d1..09fb3539 100644
--- a/lib/libalpm/po/Makevars
+++ b/lib/libalpm/po/Makevars
@@ -4,7 +4,7 @@
DOMAIN = libalpm
# These two variables depend on the location of this directory.
-subdir = po
+subdir = lib/libalpm/po
top_builddir = ../../../
# These options get passed to xgettext.
diff --git a/lib/libalpm/po/ca.po b/lib/libalpm/po/ca.po
index 6ada8f4c..450dca97 100644
--- a/lib/libalpm/po/ca.po
+++ b/lib/libalpm/po/ca.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-04-12 11:15+0000\n"
"Last-Translator: hseara <hseara@gmail.com>\n"
"Language-Team: Catalan <None>\n"
@@ -153,6 +153,10 @@ msgstr "falten les metadades del paquet en %s\n"
msgid "removing invalid file: %s\n"
msgstr "Esborrant fitxer invàlid: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "no s'ha pogut analitzar el fitxers de descripció de paquet en %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "no s'ha definit la ruta de la base de dades\n"
@@ -220,18 +224,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "ha fallat en recuperar el fitxer '%s' des de %s : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "no es pot la reprendre la baixada de %s, s'està iniciant de nou\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "error en escriure al fitxer '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "ha fallat en recuperar el fitxer '%s' de %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s sembla estar truncat: %jd/%jd bytes\n"
@@ -381,6 +373,18 @@ msgid "could not find repository for target"
msgstr "no s'ha pogut trobar el repositori per l'objectiu"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "delta invàlid o corrupte"
@@ -405,10 +409,6 @@ msgid "failed to retrieve some files"
msgstr "ha fallat en recuperar alguns fitxers"
#, c-format
-msgid "failed to copy some file"
-msgstr "no s'ha aconseguit copiar algun arxiu"
-
-#, c-format
msgid "invalid regular expression"
msgstr "expressió regular invàlida"
@@ -421,6 +421,10 @@ msgid "download library error"
msgstr "error de la llibreria de baixades"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "error en invocar el baixador extern"
@@ -429,10 +433,6 @@ msgid "unexpected error"
msgstr "error inesperat"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "base de dades sobrepassa la grandaria màxima\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "no s'ha pogut trobar %s en la base de dades -- s'està ometent\n"
@@ -553,3 +553,18 @@ msgstr "no existeix memòria cau %s, s'està creant...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "no s'ha pogut crear la memòria cau del paquet, s'usarà /tmp\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "no es pot la reprendre la baixada de %s, s'està iniciant de nou\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "error en escriure al fitxer '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "ha fallat en recuperar el fitxer '%s' de %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "no s'ha aconseguit copiar algun arxiu"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "base de dades sobrepassa la grandaria màxima\n"
diff --git a/lib/libalpm/po/cs.po b/lib/libalpm/po/cs.po
index 0aa8ad3a..c2d51f4d 100644
--- a/lib/libalpm/po/cs.po
+++ b/lib/libalpm/po/cs.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: vogo <vojtech.gondzala@gmail.com>\n"
"Language-Team: Czech <None>\n"
@@ -153,6 +153,10 @@ msgstr "chybí metadata balíčku v %s\n"
msgid "removing invalid file: %s\n"
msgstr "odstraněn neplatný soubor: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "nelze zpracovat soubor s popisem balíčku v %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "cesta k databázi není definována\n"
@@ -219,18 +223,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "selhalo získání souboru '%s' z %s: %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "nelze navázat stahování %s, začíná se znovu\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "chyba při zápisu do souboru '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "selhalo získání souboru '%s' z %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s se zdá být zkrácen: %jd/%jd bytů\n"
@@ -379,6 +371,18 @@ msgid "could not find repository for target"
msgstr "nelze nalézt repositář cíle"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "neplatný nebo poškozený delta rozdíl"
@@ -403,10 +407,6 @@ msgid "failed to retrieve some files"
msgstr "selhalo získání některých souborů"
#, c-format
-msgid "failed to copy some file"
-msgstr "selhalo kopírování souboru"
-
-#, c-format
msgid "invalid regular expression"
msgstr "nesprávný regulární výraz"
@@ -419,6 +419,10 @@ msgid "download library error"
msgstr "chyba knihovny pro stahování souborů"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "chyba volání externího programu pro stahování souborů"
@@ -427,10 +431,6 @@ msgid "unexpected error"
msgstr "neočekávaná chyba"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "databáze je větší než maximální přípustná velikost\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "nelze nalézt %s v databázi -- vynechat\n"
@@ -549,3 +549,18 @@ msgstr "neexistuje mezipaměť %s, vytváří se...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "nelze vytvořit mezipaměť balíčků, používá se /tmp\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "nelze navázat stahování %s, začíná se znovu\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "chyba při zápisu do souboru '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "selhalo získání souboru '%s' z %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "selhalo kopírování souboru"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "databáze je větší než maximální přípustná velikost\n"
diff --git a/lib/libalpm/po/da.po b/lib/libalpm/po/da.po
index 9f506e90..11253c77 100644
--- a/lib/libalpm/po/da.po
+++ b/lib/libalpm/po/da.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: toofishes <dpmcgee@gmail.com>\n"
"Language-Team: Danish <None>\n"
@@ -153,6 +153,10 @@ msgstr "manglende pakkemetadata i %s\n"
msgid "removing invalid file: %s\n"
msgstr ""
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "kunne ikke fortolke pakkebeskrivelsesfil i %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "databasesti er udefineret\n"
@@ -218,18 +222,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "fejlede i indhentning af fil »%s« fra %s: %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "det er ikke muligt at genoptage hentning af %s; starter forfra\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "fejl under skrivning til fil »%s«: %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "kunne ikke indhente fil »%s« fra %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s ser ud til at være afkortet: %jd/%jd byte\n"
@@ -378,6 +370,18 @@ msgid "could not find repository for target"
msgstr "kunne ikke finde arkiv for mål"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "ugyldig eller ødelagt delta"
@@ -402,10 +406,6 @@ msgid "failed to retrieve some files"
msgstr "kunne ikke indhente nogle filer"
#, c-format
-msgid "failed to copy some file"
-msgstr ""
-
-#, c-format
msgid "invalid regular expression"
msgstr "ugyldigt regulært udtryk"
@@ -418,6 +418,10 @@ msgid "download library error"
msgstr "hent biblioteksfejl"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "fejl under opstart af ekstern hentningsprogram"
@@ -426,10 +430,6 @@ msgid "unexpected error"
msgstr "uventet fejl"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr ""
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "kunne ikke finde %s i database - springer over\n"
@@ -548,3 +548,12 @@ msgstr "intet %s-mellemlager findes, opretter...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "kunne ikke oprette pakkemellemlager, bruger /tmp i steden for\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "det er ikke muligt at genoptage hentning af %s; starter forfra\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "fejl under skrivning til fil »%s«: %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "kunne ikke indhente fil »%s« fra %s\n"
diff --git a/lib/libalpm/po/de.po b/lib/libalpm/po/de.po
index cdda63d1..50853a2a 100644
--- a/lib/libalpm/po/de.po
+++ b/lib/libalpm/po/de.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: tlaloc <matthias@archlinux.de>\n"
"Language-Team: German <None>\n"
@@ -157,6 +157,10 @@ msgstr "Fehlende Paket-Metadaten in %s\n"
msgid "removing invalid file: %s\n"
msgstr "Entferne ungültige Datei: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "Konnte Paket-Beschreibungsdatei in %s nicht analysieren\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "Datenbank-Pfad ist nicht definiert\n"
@@ -223,18 +227,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "Konnte Datei '%s' nicht von %s übertragen : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "Kann den Download von %s nicht wieder aufnehmen, starte neu\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "Fehler beim Beschreiben von Datei '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "Konnte Datei '%s' nicht von %s übertragen\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s scheint verstümmelt zu sein: %jd/%jd Byte\n"
@@ -384,6 +376,18 @@ msgid "could not find repository for target"
msgstr "Konnte kein Repositorium für das Ziel finden"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "Ungültiges oder beschädigtes Delta"
@@ -408,10 +412,6 @@ msgid "failed to retrieve some files"
msgstr "Konnte manche Dateien nicht übertragen"
#, c-format
-msgid "failed to copy some file"
-msgstr "Konnte irgendeine Datei nicht kopieren"
-
-#, c-format
msgid "invalid regular expression"
msgstr "Ungültiger Regulärer Ausdruck"
@@ -424,6 +424,10 @@ msgid "download library error"
msgstr "Fehler in der Bibliothek für Downloads"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "Fehler beim Aufruf eines externen Downloaders"
@@ -432,10 +436,6 @@ msgid "unexpected error"
msgstr "Unerwarteter Fehler"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "Datenbank überschreitet die maximal erlaubte Größe\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "Konnte %s nicht in Datenbank finden -- Überspringe\n"
@@ -554,3 +554,18 @@ msgstr "Es existiert kein %s-Puffer. Erstelle... \n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "Konnte Paketpuffer nicht erstellen, benutze stattdessen /tmp\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "Kann den Download von %s nicht wieder aufnehmen, starte neu\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "Fehler beim Beschreiben von Datei '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "Konnte Datei '%s' nicht von %s übertragen\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "Konnte irgendeine Datei nicht kopieren"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "Datenbank überschreitet die maximal erlaubte Größe\n"
diff --git a/lib/libalpm/po/el.po b/lib/libalpm/po/el.po
index 68523f8c..b2d8c626 100644
--- a/lib/libalpm/po/el.po
+++ b/lib/libalpm/po/el.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-04-08 16:42+0000\n"
"Last-Translator: nous <nous@archlinux.us>\n"
"Language-Team: Greek <None>\n"
@@ -153,6 +153,10 @@ msgstr "απόντα μετα-δεδομένα πακέτου στο %s\n"
msgid "removing invalid file: %s\n"
msgstr "διαγραφή άκυρου αρχείου: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "αδυναμία ανάλυσης αρχείου περιγραφής πακέτου στο %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "ακαθόριστη διαδρομή βάσης\n"
@@ -218,18 +222,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "αποτυχία λήψης αρχείου '%s' από %s : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "συνέχιση λήψης %s αδύνατη, επανεκκίνηση\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "σφάλμα εγγραφής στο '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "αποτυχία λήψης αρχείου '%s' από %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "το %s δείχνει ημιτελές: %jd/%jd bytes\n"
@@ -378,6 +370,18 @@ msgid "could not find repository for target"
msgstr "αδυναμία εύρεσης αποθήκης για διεκπεραίωση"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "άκυρο ή κατεστραμμένο delta"
@@ -402,10 +406,6 @@ msgid "failed to retrieve some files"
msgstr "αποτυχία λήψης κάποιων αρχείων"
#, c-format
-msgid "failed to copy some file"
-msgstr "αποτυχία αντιγραφής αρχείου"
-
-#, c-format
msgid "invalid regular expression"
msgstr "άκυρη κανονική έκφραση"
@@ -418,6 +418,10 @@ msgid "download library error"
msgstr "σφάλμα βιβλιοθήκης λήψης"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "σφάλμα κλήσης προγράμματος λήψης"
@@ -426,10 +430,6 @@ msgid "unexpected error"
msgstr "απροσδόκητο σφάλμα"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "βάση μεγαλύτερη από μέγιστο όριο\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "δεν βρέθηκε το %s στη βάση -- παράλειψη\n"
@@ -549,3 +549,18 @@ msgstr "δημιουργία κρύπτης %s...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "αδυναμία δημιουργίας κρύπτης πακέτων, χρήση /tmp\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "συνέχιση λήψης %s αδύνατη, επανεκκίνηση\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "σφάλμα εγγραφής στο '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "αποτυχία λήψης αρχείου '%s' από %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "αποτυχία αντιγραφής αρχείου"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "βάση μεγαλύτερη από μέγιστο όριο\n"
diff --git a/lib/libalpm/po/en_GB.po b/lib/libalpm/po/en_GB.po
index d6cd67d7..02037648 100644
--- a/lib/libalpm/po/en_GB.po
+++ b/lib/libalpm/po/en_GB.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: toofishes <dpmcgee@gmail.com>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
@@ -153,6 +153,10 @@ msgstr "missing package metadata in %s\n"
msgid "removing invalid file: %s\n"
msgstr "removing invalid file: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "could not parse package description file in %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "database path is undefined\n"
@@ -218,18 +222,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "failed retrieving file '%s' from %s : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "resuming download of %s not possible; starting over\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "error writing to file '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "failed retrieving file '%s' from %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s appears to be truncated: %jd/%jd bytes\n"
@@ -378,6 +370,18 @@ msgid "could not find repository for target"
msgstr "could not find repository for target"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "invalid or corrupted delta"
@@ -402,10 +406,6 @@ msgid "failed to retrieve some files"
msgstr "failed to retrieve some files"
#, c-format
-msgid "failed to copy some file"
-msgstr "failed to copy some file"
-
-#, c-format
msgid "invalid regular expression"
msgstr "invalid regular expression"
@@ -418,6 +418,10 @@ msgid "download library error"
msgstr "download library error"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "error invoking external downloader"
@@ -426,10 +430,6 @@ msgid "unexpected error"
msgstr "unexpected error"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "database larger than maximum size\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "could not find %s in database -- skipping\n"
@@ -548,3 +548,18 @@ msgstr "no %s cache exists, creating...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "couldn't create package cache, using /tmp instead\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "resuming download of %s not possible; starting over\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "error writing to file '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "failed retrieving file '%s' from %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "failed to copy some file"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "database larger than maximum size\n"
diff --git a/lib/libalpm/po/es.po b/lib/libalpm/po/es.po
index 480e4308..afd41236 100644
--- a/lib/libalpm/po/es.po
+++ b/lib/libalpm/po/es.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: angvp <angvp@archlinux.org>\n"
"Language-Team: Spanish (Castilian) <>\n"
@@ -157,6 +157,10 @@ msgstr "faltan los metadatos del paquete en %s\n"
msgid "removing invalid file: %s\n"
msgstr "eliminando archivo inválido: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "no se pudo interpretar el archivo de descripción en %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "la ruta de la base de datos no está definida\n"
@@ -226,18 +230,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "fallo al obtener archivo '%s' desde %s: %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "no es posible continuar la descarga de %s; empezando de nuevo\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "no se pudo escribir al archivo '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "error al obtener el archivo '%s' desde %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s parece estar truncado: %jd/%jd bytes\n"
@@ -387,6 +379,18 @@ msgid "could not find repository for target"
msgstr "no pudo encontrarse un repositorio para el objetivo"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "no válido o diferencial dañado"
@@ -411,10 +415,6 @@ msgid "failed to retrieve some files"
msgstr "error al descargar algunos archivos"
#, c-format
-msgid "failed to copy some file"
-msgstr "error al copiar algún archivo"
-
-#, c-format
msgid "invalid regular expression"
msgstr "expresión regular no válida"
@@ -427,6 +427,10 @@ msgid "download library error"
msgstr "error de descarga de biblioteca"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "error invocando el descargador externo"
@@ -435,10 +439,6 @@ msgid "unexpected error"
msgstr "error inesperado"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "la base de datos supera el tamaño máximo\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "no se pudo encontrar %s en la base de datos -- saltando\n"
@@ -559,3 +559,18 @@ msgstr "no existe la caché %s, creando...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "no se pudo crear la cache de paquetes, usando /tmp en su lugar\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "no es posible continuar la descarga de %s; empezando de nuevo\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "no se pudo escribir al archivo '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "error al obtener el archivo '%s' desde %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "error al copiar algún archivo"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "la base de datos supera el tamaño máximo\n"
diff --git a/lib/libalpm/po/fi.po b/lib/libalpm/po/fi.po
index 09909f56..8af1205a 100644
--- a/lib/libalpm/po/fi.po
+++ b/lib/libalpm/po/fi.po
@@ -158,6 +158,10 @@ msgstr "paketin metadata puuttuu tiedostosta %s\n"
msgid "removing invalid file: %s\n"
msgstr "poistetaan virheellinen tiedosto: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "paketin kuvausta tiedostossa %s ei voitu jäsentää\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "tietokannan polkua ei ole määritelty\n"
@@ -223,18 +227,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "tiedoston '%s' nouto palvelimelta %s epäonnistui : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "tiedoston %s latauksen jatkaminen ei mahdollista; aloitetaan alusta\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "virhe kirjoitettaessa tiedostoon '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "tiedoston '%s' nouto palvelimelta %s epäonnistui\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s näyttää katkenneen: %jd/%jd tavua\n"
@@ -383,6 +375,18 @@ msgid "could not find repository for target"
msgstr "kohteen varastoa ei löytynyt"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "delta ei kelvollinen tai vahingoittunut"
@@ -407,10 +411,6 @@ msgid "failed to retrieve some files"
msgstr "joidenkin tiedostojen nouto epäonnistui"
#, c-format
-msgid "failed to copy some file"
-msgstr "jonkin tiedoston kopiointi epäonnistui"
-
-#, c-format
msgid "invalid regular expression"
msgstr "virheellinen säännöllinen lauseke"
@@ -423,6 +423,10 @@ msgid "download library error"
msgstr "latauskirjaston virhe"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "virhe kutsuttaessa ulkoista latausohjelmaa"
@@ -431,10 +435,6 @@ msgid "unexpected error"
msgstr "odottamaton virhe"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "tietokanta enimmäiskokoa suurempi\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "%s ei löytynyt tietokannasta -- ohitetaan\n"
@@ -555,3 +555,19 @@ msgstr "välimuistia %s ei ole olemassa, luodaan...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "pakettivälimuistia ei voitu luoda, käytetään /tmp:tä sen sijasta\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr ""
+#~ "tiedoston %s latauksen jatkaminen ei mahdollista; aloitetaan alusta\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "virhe kirjoitettaessa tiedostoon '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "tiedoston '%s' nouto palvelimelta %s epäonnistui\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "jonkin tiedoston kopiointi epäonnistui"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "tietokanta enimmäiskokoa suurempi\n"
diff --git a/lib/libalpm/po/fr.po b/lib/libalpm/po/fr.po
index 48d0d6c8..f2279c68 100644
--- a/lib/libalpm/po/fr.po
+++ b/lib/libalpm/po/fr.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-23 07:04+0000\n"
"Last-Translator: toofishes <dpmcgee@gmail.com>\n"
"Language-Team: French <>\n"
@@ -153,6 +153,10 @@ msgstr "méta-données du paquet manquantes dans %s\n"
msgid "removing invalid file: %s\n"
msgstr "suppression du fichier invalide: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "l'analyse du fichier de description a échoué dans %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "base de données non initialisée\n"
@@ -221,18 +225,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "échec de récupération du fichier '%s' depuis %s : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "le téléchargement de %s ne peut pas être continué, reprise au début\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "écriture dans le fichier '%s' impossible: %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "échec de récupération du fichier '%s' depuis %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s est apparemment tronqué: %jd/%jd bytes\n"
@@ -383,6 +375,18 @@ msgid "could not find repository for target"
msgstr "impossible de trouver le dépôt pour la cible"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "delta invalide ou corrompu"
@@ -407,10 +411,6 @@ msgid "failed to retrieve some files"
msgstr "échec de récupération de certains fichiers"
#, c-format
-msgid "failed to copy some file"
-msgstr "erreur lors d'une copie de fichier"
-
-#, c-format
msgid "invalid regular expression"
msgstr "expression régulière incorrecte"
@@ -423,6 +423,10 @@ msgid "download library error"
msgstr "erreur de la bibliothèque de téléchargement"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "erreur en invoquant le client externe de téléchargement"
@@ -431,10 +435,6 @@ msgid "unexpected error"
msgstr "erreur non prévue"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "la base de données est plus grande que la taille maximale\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "trouver %s dans la base de données a échoué -- ignoré\n"
@@ -553,3 +553,19 @@ msgstr "le cache %s n'existe pas, création...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "n'a pas pu créer le cache de paquets, /tmp sera utilisé à la place\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr ""
+#~ "le téléchargement de %s ne peut pas être continué, reprise au début\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "écriture dans le fichier '%s' impossible: %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "échec de récupération du fichier '%s' depuis %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "erreur lors d'une copie de fichier"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "la base de données est plus grande que la taille maximale\n"
diff --git a/lib/libalpm/po/hu.po b/lib/libalpm/po/hu.po
index e49075a7..ec796cb4 100644
--- a/lib/libalpm/po/hu.po
+++ b/lib/libalpm/po/hu.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: ngaba <ngaba@bibl.u-szeged.hu>\n"
"Language-Team: Hungarian <None>\n"
@@ -153,6 +153,10 @@ msgstr "hiányzó csomaginformációs fájl itt: %s\n"
msgid "removing invalid file: %s\n"
msgstr "hibás fájl eltávolítása: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "nem sikerült értelmezni a(z) %s csomagleíró fájlját\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "az adatbázis-útvonal nincs megadva\n"
@@ -220,18 +224,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "nem sikerült a(z) '%s' fájlt letölteni a %s helyről : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "nem tudom folytatni a(z) %s letöltését; újrakezdem\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "hiba a(z) '%s' fájl írása során: %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "nem sikerült a(z) '%s' fájlt letölteni a %s helyről\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "úgy tűnik, hogy %s csonka: %jd/%jd bájt\n"
@@ -380,6 +372,18 @@ msgid "could not find repository for target"
msgstr "nem található repó a célcsomaghoz"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "hibás vagy sérült delta"
@@ -404,10 +408,6 @@ msgid "failed to retrieve some files"
msgstr "nem sikerült néhány fájlt letölteni"
#, c-format
-msgid "failed to copy some file"
-msgstr "nem sikerült néhány fájlt másolni"
-
-#, c-format
msgid "invalid regular expression"
msgstr "hibás reguláris kifejezés"
@@ -420,6 +420,10 @@ msgid "download library error"
msgstr "letöltőkönyvtár hiba"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "hiba a külső letöltő meghívásakor"
@@ -428,10 +432,6 @@ msgid "unexpected error"
msgstr "nemvárt hiba"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "az adatbázis nagyobb, mint a maximális megengedett méret\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "nem található a(z) %s az adatbázisban -- kihagyás\n"
@@ -550,3 +550,18 @@ msgstr "nem létezik a(z) %s gyorsítótár. létrehozás...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "nem sikerült létrehozni a csomaggyorsítótárat, a /tmp használata\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "nem tudom folytatni a(z) %s letöltését; újrakezdem\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "hiba a(z) '%s' fájl írása során: %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "nem sikerült a(z) '%s' fájlt letölteni a %s helyről\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "nem sikerült néhány fájlt másolni"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "az adatbázis nagyobb, mint a maximális megengedett méret\n"
diff --git a/lib/libalpm/po/it.po b/lib/libalpm/po/it.po
index 35a3c0ca..770c26f1 100644
--- a/lib/libalpm/po/it.po
+++ b/lib/libalpm/po/it.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: giovanni <giovanni@archlinux.org>\n"
"Language-Team: Italian <None>\n"
@@ -158,6 +158,10 @@ msgstr "manca il metadata del pacchetto in %s\n"
msgid "removing invalid file: %s\n"
msgstr "rimozione del file non valido: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "impossibile analizzare il file di descrizione del pacchetto in %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "il percorso del database non è stato definito\n"
@@ -226,18 +230,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "impossibile scaricare il pacchetto '%s' da %s : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "impossibile riprendere il download di %s\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "si è verificato un errore durante la scrittura nel file '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "impossibile scaricare il pacchetto '%s' da %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s sembra essere incompleto: %jd/%jd byte\n"
@@ -386,6 +378,18 @@ msgid "could not find repository for target"
msgstr "impossibile trovare un repository contenente questo pacchetto"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "il delta non è valido oppure è corrotto"
@@ -410,10 +414,6 @@ msgid "failed to retrieve some files"
msgstr "impossibile scaricare alcuni file"
#, c-format
-msgid "failed to copy some file"
-msgstr "impossibile copiare alcuni file"
-
-#, c-format
msgid "invalid regular expression"
msgstr "l'espressione regolare non è valida"
@@ -426,6 +426,10 @@ msgid "download library error"
msgstr "si è verificato un errore della libreria di download"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "si è verificato un errore lanciando il downloader esterno"
@@ -434,11 +438,6 @@ msgid "unexpected error"
msgstr "errore inaspettato"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr ""
-"la grandezza del database è superiore alla dimensione massima consentita\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "impossibile trovare %s nel database, sarà ignorato\n"
@@ -560,3 +559,19 @@ msgstr "la cache di %s non esiste, creazione in corso...\n"
msgid "couldn't create package cache, using /tmp instead\n"
msgstr ""
"impossibile creare la cache del pacchetto, al suo posto sarà usata /tmp\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "impossibile riprendere il download di %s\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "si è verificato un errore durante la scrittura nel file '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "impossibile scaricare il pacchetto '%s' da %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "impossibile copiare alcuni file"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr ""
+#~ "la grandezza del database è superiore alla dimensione massima consentita\n"
diff --git a/lib/libalpm/po/kk.po b/lib/libalpm/po/kk.po
index f0bce740..53c5d13f 100644
--- a/lib/libalpm/po/kk.po
+++ b/lib/libalpm/po/kk.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: toofishes <dpmcgee@gmail.com>\n"
"Language-Team: Kazakh <None>\n"
@@ -153,6 +153,10 @@ msgstr "%s ішінде дестенің мета мәліметтері жоқ\
msgid "removing invalid file: %s\n"
msgstr "қате файлды өшіру: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "%s ішіндегі анықтама файлын зерттеу мүмкін емес\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "дерекқорға жол анықталмаған\n"
@@ -218,18 +222,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "'%s' файлын %s адресінен алу қатемен аяқталды : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "%s жүктемесін жалғастыру мүмкін емес; басынан басталады\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "'%s' файлына жазу қатесі: %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "'%s' файлын %s адресінен алу қатемен аяқталды\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s қысқартылған сияқты: %jd/%jd байт\n"
@@ -378,6 +370,18 @@ msgid "could not find repository for target"
msgstr "көрсетілген мақсат үшін репозиторийді табу мүмкін емес"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "дельта файлы қате не зақымдалған"
@@ -402,10 +406,6 @@ msgid "failed to retrieve some files"
msgstr "кейбір файлдарды алу сәтсіз аяқталды"
#, c-format
-msgid "failed to copy some file"
-msgstr "кейбір файлдарды көшіру сәтсіз"
-
-#, c-format
msgid "invalid regular expression"
msgstr "тұрақты өрнек дұрыс емес"
@@ -418,6 +418,10 @@ msgid "download library error"
msgstr "download library қатесі орын алды"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "сыртқы жүктемелер менеджерін шақыру қатемен аяқталды"
@@ -426,10 +430,6 @@ msgid "unexpected error"
msgstr "күтпеген қате кетті"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "дерекқор рұқсат етілген өлшемінен үлкен\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "дерекқор ішінде %s табылмады -- өткізіп жібереміз\n"
@@ -549,3 +549,18 @@ msgstr "%s кэші жоқ болып тұр, құрылады...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "дестелер кэшін құру мүмкін емес, оның орнына /tmp қолданылады\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "%s жүктемесін жалғастыру мүмкін емес; басынан басталады\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "'%s' файлына жазу қатесі: %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "'%s' файлын %s адресінен алу қатемен аяқталды\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "кейбір файлдарды көшіру сәтсіз"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "дерекқор рұқсат етілген өлшемінен үлкен\n"
diff --git a/lib/libalpm/po/libalpm.pot b/lib/libalpm/po/libalpm.pot
index 768ea204..1f7d25a7 100644
--- a/lib/libalpm/po/libalpm.pot
+++ b/lib/libalpm/po/libalpm.pot
@@ -152,6 +152,10 @@ msgid "removing invalid file: %s\n"
msgstr ""
#, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr ""
+
+#, c-format
msgid "database path is undefined\n"
msgstr ""
@@ -216,18 +220,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr ""
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr ""
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr ""
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr ""
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr ""
@@ -376,6 +368,18 @@ msgid "could not find repository for target"
msgstr ""
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr ""
@@ -400,10 +404,6 @@ msgid "failed to retrieve some files"
msgstr ""
#, c-format
-msgid "failed to copy some file"
-msgstr ""
-
-#, c-format
msgid "invalid regular expression"
msgstr ""
@@ -416,15 +416,15 @@ msgid "download library error"
msgstr ""
#, c-format
-msgid "error invoking external downloader"
+msgid "gpgme error"
msgstr ""
#, c-format
-msgid "unexpected error"
+msgid "error invoking external downloader"
msgstr ""
#, c-format
-msgid "database larger than maximum size\n"
+msgid "unexpected error"
msgstr ""
#, c-format
diff --git a/lib/libalpm/po/nb.po b/lib/libalpm/po/nb.po
index 9349423e..b44a3ad5 100644
--- a/lib/libalpm/po/nb.po
+++ b/lib/libalpm/po/nb.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-04-16 00:45+0000\n"
"Last-Translator: Jonhoo <jon@thesquareplanet.com>\n"
"Language-Team: Norwegian Bokmål <None>\n"
@@ -153,6 +153,10 @@ msgstr "mangler metadata i %s\n"
msgid "removing invalid file: %s\n"
msgstr "fjerner ugyldig fil: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "kunne ikke analysere pakkebeskrivelse i fil %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "databaseplassering er udefinert\n"
@@ -219,18 +223,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "mottakelse av fil '%s' fra %s : %s feilet\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "kan ikke fortsette nedlastingen av %s; starter på nytt\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "skriving til fil '%s': %s feilet\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "mottakelse av fil '%s' fra %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s ser ut til å være trunkert: %jd/%jd bytes\n"
@@ -379,6 +371,18 @@ msgid "could not find repository for target"
msgstr "fant ikke pakkebrønn for mål"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "invalid"
@@ -403,10 +407,6 @@ msgid "failed to retrieve some files"
msgstr "mottagelsen av noen filer feilet"
#, c-format
-msgid "failed to copy some file"
-msgstr "kunne ikke kopiere en fil"
-
-#, c-format
msgid "invalid regular expression"
msgstr "ugyldig uttrykk"
@@ -419,6 +419,10 @@ msgid "download library error"
msgstr "feil i nedlastingsbibliotek"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "påkalling av ekstern nedlaster feilet"
@@ -427,10 +431,6 @@ msgid "unexpected error"
msgstr "uforventet feil"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "databasen er større enn maksstørrelsen\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "kunne ikke finne %s i database -- hopper over\n"
@@ -549,3 +549,18 @@ msgstr "ingen %s cache eksisterer, lager en ...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "kunne ikke danne pakke-cache, bruker /tmp istedenfor\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "kan ikke fortsette nedlastingen av %s; starter på nytt\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "skriving til fil '%s': %s feilet\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "mottakelse av fil '%s' fra %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "kunne ikke kopiere en fil"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "databasen er større enn maksstørrelsen\n"
diff --git a/lib/libalpm/po/pl.po b/lib/libalpm/po/pl.po
index 667a564c..5915d1e2 100644
--- a/lib/libalpm/po/pl.po
+++ b/lib/libalpm/po/pl.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-04-12 20:00+0000\n"
"Last-Translator: Barthalion <barthalion@gmail.com>\n"
"Language-Team: Polish <None>\n"
@@ -154,6 +154,10 @@ msgstr "brak metadanych pakietu w %s\n"
msgid "removing invalid file: %s\n"
msgstr "usuwanie nieprawidłowego pliku: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "nie udało się przeczytać opisu pliku w %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "ścieżka bazy danych jest niezdefiniowana\n"
@@ -220,18 +224,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "nie udało się pobrać pliku '%s' z %s : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "kontynuowanie pobieranie %s jest niemożliwe; zaczynam od nowa\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "Błąd podczas zapisywania do pliku '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "nie udało się pobrać pliku '%s' z %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s wygląda, jakby został obcięty %jd/%jd bajtów\n"
@@ -380,6 +372,18 @@ msgid "could not find repository for target"
msgstr "nie mogę znaleźć repozytorium dla celu"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "nieprawidłowy bądź uszkodzony pakiet przyrostowy"
@@ -404,10 +408,6 @@ msgid "failed to retrieve some files"
msgstr "nie udało się odzyskać niektórych plików"
#, c-format
-msgid "failed to copy some file"
-msgstr "bład kopiowania niektórych plików"
-
-#, c-format
msgid "invalid regular expression"
msgstr "nieprawidłowe wyrażenie regularne"
@@ -420,6 +420,10 @@ msgid "download library error"
msgstr "błąd pobierania biblioteki"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr ""
"wystąpił błąd podczas odwoływania się do zewnętrznego programu pobierającego"
@@ -429,10 +433,6 @@ msgid "unexpected error"
msgstr "niespodziewany błąd"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "baza danych jest większa, niż maksymalny rozmiar\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "nie udało się odnaleźć %s w bazie danych -- pomijanie\n"
@@ -552,3 +552,18 @@ msgstr "brak pamięci podręcznej dla %s, tworzenie...\n"
msgid "couldn't create package cache, using /tmp instead\n"
msgstr ""
"nie udało się stworzyć pamięci podręcznej pakietu, używanie /tmp w zamian\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "kontynuowanie pobieranie %s jest niemożliwe; zaczynam od nowa\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "Błąd podczas zapisywania do pliku '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "nie udało się pobrać pliku '%s' z %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "bład kopiowania niektórych plików"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "baza danych jest większa, niż maksymalny rozmiar\n"
diff --git a/lib/libalpm/po/pt.po b/lib/libalpm/po/pt.po
index 0d936bcd..3a82710e 100644
--- a/lib/libalpm/po/pt.po
+++ b/lib/libalpm/po/pt.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-04-16 01:24+0000\n"
"Last-Translator: ArchGalileu <omeuviolino@gmail.com>\n"
"Language-Team: Portuguese <>\n"
@@ -154,6 +154,10 @@ msgstr "em falta metadados do pacote em %s\n"
msgid "removing invalid file: %s\n"
msgstr "a remover ficheiro inválido: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "não foi possível interpretar o ficheiro de descrição do pacote em %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "localização da base de dados não definida\n"
@@ -223,18 +227,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "falha ao obter ficheiro '%s' de %s : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "não foi possível retomar a descarga de %s; a reiniciar a descarga\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "erro ao escrever no ficheiro '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "falha ao obter o ficheiro '%s' de %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s parece estar quebrado: %jd/%jd bytes\n"
@@ -383,6 +375,18 @@ msgid "could not find repository for target"
msgstr "não foi possível encontrar o repositório para o pacote"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "delta inválido ou corrompido"
@@ -407,10 +411,6 @@ msgid "failed to retrieve some files"
msgstr "falha ao descarregar alguns ficheiros"
#, c-format
-msgid "failed to copy some file"
-msgstr "falhou ao copiar algum ficheiro"
-
-#, c-format
msgid "invalid regular expression"
msgstr "expressão regular inválida"
@@ -423,6 +423,10 @@ msgid "download library error"
msgstr "erro na biblioteca de descargas"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "erro ao invocar o programa de descargas externo"
@@ -431,10 +435,6 @@ msgid "unexpected error"
msgstr "erro inesperado"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "a base de dados é maior que o tamanho máximo\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "não foi possível encontrar %s na base de dados - a ignorar\n"
@@ -554,3 +554,18 @@ msgstr "cache %s não existe, a criar...\n"
msgid "couldn't create package cache, using /tmp instead\n"
msgstr ""
"não foi possível criar cache de pacotes, a usar /tmp como alternativa\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "não foi possível retomar a descarga de %s; a reiniciar a descarga\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "erro ao escrever no ficheiro '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "falha ao obter o ficheiro '%s' de %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "falhou ao copiar algum ficheiro"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "a base de dados é maior que o tamanho máximo\n"
diff --git a/lib/libalpm/po/pt_BR.po b/lib/libalpm/po/pt_BR.po
index 14815650..d2980e94 100644
--- a/lib/libalpm/po/pt_BR.po
+++ b/lib/libalpm/po/pt_BR.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-04-12 02:29+0000\n"
"Last-Translator: ambaratti <ambaratti.listas@gmail.com>\n"
"Language-Team: Portuguese (Brazilian) <None>\n"
@@ -155,6 +155,10 @@ msgstr "faltando metadados do pacote em %s\n"
msgid "removing invalid file: %s\n"
msgstr "removendo arquivo inválido: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "não foi possível interpretar o arquivo de descrição do pacote em %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "caminho da base de dados não definido\n"
@@ -223,18 +227,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "falha ao obter o arquivo '%s' de %s : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "não foi possível retomar o download de %s; começando de novo\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "erro ao escrever no arquivo '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "falha ao obter arquivo '%s' de %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s parece estar truncado: %jd/%jd bytes\n"
@@ -383,6 +375,18 @@ msgid "could not find repository for target"
msgstr "não foi possível encontrar o repositório para o pacote"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "delta inválido ou corrompido"
@@ -407,10 +411,6 @@ msgid "failed to retrieve some files"
msgstr "falha ao obter alguns arquivos"
#, c-format
-msgid "failed to copy some file"
-msgstr "falha ao copiar algum arquivo"
-
-#, c-format
msgid "invalid regular expression"
msgstr "expressão regular inválida"
@@ -423,6 +423,10 @@ msgid "download library error"
msgstr "erro na biblioteca de download"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "erro ao chamar o programa de download externo"
@@ -431,10 +435,6 @@ msgid "unexpected error"
msgstr "erro inesperado"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "banco de dados maior que o tamanho máximo\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "não foi possível encontrar %s na base de dados -- ignorando\n"
@@ -553,3 +553,18 @@ msgstr "cache %s não existe, criando...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "não foi possível criar cache de pacotes, usando /tmp em seu lugar\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "não foi possível retomar o download de %s; começando de novo\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "erro ao escrever no arquivo '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "falha ao obter arquivo '%s' de %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "falha ao copiar algum arquivo"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "banco de dados maior que o tamanho máximo\n"
diff --git a/lib/libalpm/po/ro.po b/lib/libalpm/po/ro.po
index cd83cc66..f3d7bec2 100644
--- a/lib/libalpm/po/ro.po
+++ b/lib/libalpm/po/ro.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: wonder <ibiru@archlinux.org>\n"
"Language-Team: Romanian <>\n"
@@ -159,6 +159,10 @@ msgstr "lipsă metadate pentru pachet în %s\n"
msgid "removing invalid file: %s\n"
msgstr "se elimină fișierul nevalid: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "nu a putut fi analizat fișierul de descriere a pachetului în %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "calea bazei de date este nedefinită\n"
@@ -225,20 +229,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "eșec la obținerea fișierului '%s' din %s : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr ""
-"nu se poate relua descărcarea pentru %s; se reîncepe\n"
-"\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "eroare la scriere în fișierul '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "eșec la obținerea fișierului '%s' din %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s pare a fi trunchiat: %jd/%jd bytes\n"
@@ -387,6 +377,18 @@ msgid "could not find repository for target"
msgstr "depozitul pentru țintă nu poate fi găsit"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "delta invalid sau corupt"
@@ -411,10 +413,6 @@ msgid "failed to retrieve some files"
msgstr "eșec în obținerea unor fișiere"
#, c-format
-msgid "failed to copy some file"
-msgstr "copierea unui fișier a eșuat"
-
-#, c-format
msgid "invalid regular expression"
msgstr "expresie regulată nevalidă"
@@ -427,6 +425,10 @@ msgid "download library error"
msgstr "eroare în biblioteca de descărcare"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "eroare la invocarea descărcătorului extern"
@@ -435,10 +437,6 @@ msgid "unexpected error"
msgstr "eroare neașteptată"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "baza de date e mai mare decât dimensiunea maximă\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "nu poate fi găsit %s în baza de date -- se omite\n"
@@ -557,3 +555,20 @@ msgstr "nu există cache %s, se crează...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "nu se poate crea cache pachet, se folosește /tmp în schimb\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr ""
+#~ "nu se poate relua descărcarea pentru %s; se reîncepe\n"
+#~ "\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "eroare la scriere în fișierul '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "eșec la obținerea fișierului '%s' din %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "copierea unui fișier a eșuat"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "baza de date e mai mare decât dimensiunea maximă\n"
diff --git a/lib/libalpm/po/ru.po b/lib/libalpm/po/ru.po
index c56b6fd0..93f8a7e2 100644
--- a/lib/libalpm/po/ru.po
+++ b/lib/libalpm/po/ru.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-04-13 14:50+0000\n"
"Last-Translator: vdk <vdk@gmx.us>\n"
"Language-Team: Russian <None>\n"
@@ -156,6 +156,10 @@ msgstr "отсутствуют метаданные пакета в %s\n"
msgid "removing invalid file: %s\n"
msgstr "удаляется ошибочный файл: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "не удалось проанализировать файл с описанием пакета в %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "путь к базе данных не определён\n"
@@ -223,18 +227,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "не удалось получить файл '%s' из %s : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "не удалось продолжить закачку %s; начинаю заново\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "ошибка записи в файл '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "не удалось получить файл '%s' из %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s, видимо, обрезан: %jd/%jd байт\n"
@@ -383,6 +375,18 @@ msgid "could not find repository for target"
msgstr "не удалось репозиторий для цели"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "ошибка или повреждение в дельте"
@@ -407,10 +411,6 @@ msgid "failed to retrieve some files"
msgstr "не удалось получить некоторые файлы"
#, c-format
-msgid "failed to copy some file"
-msgstr "не удалось скопировать некоторые файлы"
-
-#, c-format
msgid "invalid regular expression"
msgstr "неверное регулярное выражение"
@@ -423,6 +423,10 @@ msgid "download library error"
msgstr "ошибка в библиотеке загрузки"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "ошибка вызова внешнего менеджера загрузки"
@@ -431,10 +435,6 @@ msgid "unexpected error"
msgstr "непредвиденная ошибка"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "база данных больше максимального размера\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "не удалось найти %s в базе данных -- пропускается\n"
@@ -553,3 +553,18 @@ msgstr "кэш %s не существует, создается...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "не удалось создать кэш пакетов, будет использован /tmp\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "не удалось продолжить закачку %s; начинаю заново\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "ошибка записи в файл '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "не удалось получить файл '%s' из %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "не удалось скопировать некоторые файлы"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "база данных больше максимального размера\n"
diff --git a/lib/libalpm/po/sk.po b/lib/libalpm/po/sk.po
index 55f18e75..7efec81a 100644
--- a/lib/libalpm/po/sk.po
+++ b/lib/libalpm/po/sk.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-04-17 10:09+0000\n"
"Last-Translator: jose1711 <jose1711@gmail.com>\n"
"Language-Team: Slovak <None>\n"
@@ -153,6 +153,10 @@ msgstr "chýbaju metadáta balíčka v %s\n"
msgid "removing invalid file: %s\n"
msgstr "odstraňujem neplatný súbor: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "nie je možné spracovať súbor s popisom balíčka v %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "cesta k databáze nie je definovaná\n"
@@ -219,18 +223,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "chyba pri získavaní súboru '%s' z %s: %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "nie je možné pokračovať v sťahovaní %s, začínam sťahovať od začiatku\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "chyba pri zápisu do súboru '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "zlyhalo získanie súboru '%s' z %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s vyzerá byť skrátený: %jd/%jd bytov\n"
@@ -379,6 +371,18 @@ msgid "could not find repository for target"
msgstr "nie je možné nájsť repozitár cieľa"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "neplatný alebo poškodený delta rozdiel"
@@ -403,10 +407,6 @@ msgid "failed to retrieve some files"
msgstr "chyba pri získavaní niektorých súborov"
#, c-format
-msgid "failed to copy some file"
-msgstr "nepodarilo sa skopírovať súbor"
-
-#, c-format
msgid "invalid regular expression"
msgstr "neplatný regulárny výraz"
@@ -419,6 +419,10 @@ msgid "download library error"
msgstr "chyba knižnice pre sťahovanie súborov"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "chyba volania externého programu pre sťahovanie súborov"
@@ -427,10 +431,6 @@ msgid "unexpected error"
msgstr "neočakávaná chyba"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "databáza väčšia ako maximálna veľkosť\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "nie je možné nájsť %s v databáze -- preskakujem\n"
@@ -549,3 +549,19 @@ msgstr "neexistuje cache %s, vytváram...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "nie je možné vytvoriť cache balíčkov, použijem /tmp\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr ""
+#~ "nie je možné pokračovať v sťahovaní %s, začínam sťahovať od začiatku\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "chyba pri zápisu do súboru '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "zlyhalo získanie súboru '%s' z %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "nepodarilo sa skopírovať súbor"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "databáza väčšia ako maximálna veľkosť\n"
diff --git a/lib/libalpm/po/sr.po b/lib/libalpm/po/sr.po
index 463c66b1..4d154eba 100644
--- a/lib/libalpm/po/sr.po
+++ b/lib/libalpm/po/sr.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: Xabre <githzerai06@gmail.com>\n"
"Language-Team: Serbian <None>\n"
@@ -154,6 +154,10 @@ msgstr "недостају метаподаци пакета %s\n"
msgid "removing invalid file: %s\n"
msgstr "уклањам неисправан фајл: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "не могу да обрадим фајл описа пакета у %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "путања базе није одређена\n"
@@ -220,18 +224,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "неуспешно преузимање фајла „%s“ са „%s“: %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "настављање преузимања %s није могуће: започињем изнова\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "грешка при упису у фајл „%s“: %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "неуспешно преузимање фајла „%s“ са %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "изгледа да је %s окрњен: %jd/%jd бајтова\n"
@@ -380,6 +372,18 @@ msgid "could not find repository for target"
msgstr "не могу да нађем ризницу циља"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "неисправна или покварена делта"
@@ -404,10 +408,6 @@ msgid "failed to retrieve some files"
msgstr "неуспешно преузимање неких фајлова"
#, c-format
-msgid "failed to copy some file"
-msgstr "грешка при копирању фајла"
-
-#, c-format
msgid "invalid regular expression"
msgstr "неисправан регуларни израз"
@@ -420,6 +420,10 @@ msgid "download library error"
msgstr "грешка у библиотеци преузимања"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "грешка при покретању спољног програма за преузимање"
@@ -428,10 +432,6 @@ msgid "unexpected error"
msgstr "неочекивана грешка"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "база је већа од максималне величине\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "не могу да нађем %s у бази — прескачем\n"
@@ -550,3 +550,18 @@ msgstr "не постоји кеш за %s; правим....\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "не могу да направим кеш пакета; користим /tmp као замену\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "настављање преузимања %s није могуће: започињем изнова\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "грешка при упису у фајл „%s“: %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "неуспешно преузимање фајла „%s“ са %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "грешка при копирању фајла"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "база је већа од максималне величине\n"
diff --git a/lib/libalpm/po/sr@latin.po b/lib/libalpm/po/sr@latin.po
index b2df9f68..8c1d15cc 100644
--- a/lib/libalpm/po/sr@latin.po
+++ b/lib/libalpm/po/sr@latin.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: Xabre <githzerai06@gmail.com>\n"
"Language-Team: Serbian (Latin) <None>\n"
@@ -154,6 +154,10 @@ msgstr "nedostaju metapodaci paketa %s\n"
msgid "removing invalid file: %s\n"
msgstr "uklanjam neispravan fajl: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "ne mogu da obradim fajl opisa paketa u %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "putanja baze nije određena\n"
@@ -220,18 +224,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "neuspešno preuzimanje fajla „%s“ sa „%s“: %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "nastavljanje preuzimanja %s nije moguće: započinjem iznova\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "greška pri upisu u fajl „%s“: %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "neuspešno preuzimanje fajla „%s“ sa %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "izgleda da je %s okrnjen: %jd/%jd bajtova\n"
@@ -380,6 +372,18 @@ msgid "could not find repository for target"
msgstr "ne mogu da nađem riznicu cilja"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "neispravna ili pokvarena delta"
@@ -404,10 +408,6 @@ msgid "failed to retrieve some files"
msgstr "neuspešno preuzimanje nekih fajlova"
#, c-format
-msgid "failed to copy some file"
-msgstr "greška pri kopiranju fajla"
-
-#, c-format
msgid "invalid regular expression"
msgstr "neispravan regularni izraz"
@@ -420,6 +420,10 @@ msgid "download library error"
msgstr "greška u biblioteci preuzimanja"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "greška pri pokretanju spoljnog programa za preuzimanje"
@@ -428,10 +432,6 @@ msgid "unexpected error"
msgstr "neočekivana greška"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "baza je veća od maksimalne veličine\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "ne mogu da nađem %s u bazi — preskačem\n"
@@ -550,3 +550,18 @@ msgstr "ne postoji keš za %s; pravim....\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "ne mogu da napravim keš paketa; koristim /tmp kao zamenu\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "nastavljanje preuzimanja %s nije moguće: započinjem iznova\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "greška pri upisu u fajl „%s“: %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "neuspešno preuzimanje fajla „%s“ sa %s\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "greška pri kopiranju fajla"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "baza je veća od maksimalne veličine\n"
diff --git a/lib/libalpm/po/sv.po b/lib/libalpm/po/sv.po
index ff6837ea..0d43caec 100644
--- a/lib/libalpm/po/sv.po
+++ b/lib/libalpm/po/sv.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: toofishes <dpmcgee@gmail.com>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
@@ -153,6 +153,10 @@ msgstr "saknar metadata för paketet i %s\n"
msgid "removing invalid file: %s\n"
msgstr ""
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "kunde inte analysera paketbeskrivningen i %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "sökväg till databasen är odefinierad\n"
@@ -218,18 +222,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "misslyckades hämta filen '%s' från %s : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "kan inte återuppta nerladdning av %s, börjar om\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "fel vid skrivning till filen '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "misslyckades hämta filen '%s' från %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s verkar vara trunkerad: %jd/%jd bytes\n"
@@ -378,6 +370,18 @@ msgid "could not find repository for target"
msgstr "givet förråd finns inte"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "ogiltig eller korrupt delta"
@@ -402,10 +406,6 @@ msgid "failed to retrieve some files"
msgstr "misslyckades att hämta några filer"
#, c-format
-msgid "failed to copy some file"
-msgstr ""
-
-#, c-format
msgid "invalid regular expression"
msgstr "ogiltigt vanligt uttryck"
@@ -418,6 +418,10 @@ msgid "download library error"
msgstr "fel vid nerladdning av bibliotek"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "fel vid anrop av extern nerladdare"
@@ -426,10 +430,6 @@ msgid "unexpected error"
msgstr "oväntat fel"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr ""
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "kunde inte hitta %s i databasen -- hoppar över\n"
@@ -548,3 +548,12 @@ msgstr "ingen %s cache existerar, skapar...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "kunde inte skapa paket-cache, använder /tmp istället\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "kan inte återuppta nerladdning av %s, börjar om\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "fel vid skrivning till filen '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "misslyckades hämta filen '%s' från %s\n"
diff --git a/lib/libalpm/po/tr.po b/lib/libalpm/po/tr.po
index 9305fc47..b90edf50 100644
--- a/lib/libalpm/po/tr.po
+++ b/lib/libalpm/po/tr.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: ras0ir <ras0ir@eventualis.org>\n"
"Language-Team: Turkish <None>\n"
@@ -153,6 +153,10 @@ msgstr "%s içerisinde eksik paket bilgisi\n"
msgid "removing invalid file: %s\n"
msgstr "silinen geçersiz dosya: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "%s içerisindeki paket açıklama dosyası ayrıştırılamadı\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "veritabanı yolu belirtilmemiş\n"
@@ -218,18 +222,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "%3$s hatası nedeniyle '%1$s' dosyası %2$s adresinden alınamadı\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "%s için indirme işlemine devam edilemiyor, baştan başlanıyor\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "'%s' dosyasına yazılamıyor: %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "%s dosyası %s adresinden alınamadı\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s eksik görünüyor: %jd/%jd bayt\n"
@@ -378,6 +370,18 @@ msgid "could not find repository for target"
msgstr "hedef için depo bulunamadı"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "geçersiz ya da bozuk veri"
@@ -402,10 +406,6 @@ msgid "failed to retrieve some files"
msgstr "bazı dosyalar alınamadı"
#, c-format
-msgid "failed to copy some file"
-msgstr "bazı dosyalar kopyalanamadı"
-
-#, c-format
msgid "invalid regular expression"
msgstr "geçersiz düzenli ifade"
@@ -418,6 +418,10 @@ msgid "download library error"
msgstr "indirme kütüphanesi hatası"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "harici indiriciyi çağırırken hata oluştu"
@@ -426,10 +430,6 @@ msgid "unexpected error"
msgstr "beklenmedik hata"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "veritabanı maksimum boyuttan daha büyük\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "%s veritabanında bulunamadı -- atlanıyor\n"
@@ -549,3 +549,18 @@ msgstr "%s önbelleği yok, oluşturuluyor...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "paket önbelleği oluşturulamadı, /tmp kullanılacak\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "%s için indirme işlemine devam edilemiyor, baştan başlanıyor\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "'%s' dosyasına yazılamıyor: %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "%s dosyası %s adresinden alınamadı\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "bazı dosyalar kopyalanamadı"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "veritabanı maksimum boyuttan daha büyük\n"
diff --git a/lib/libalpm/po/uk.po b/lib/libalpm/po/uk.po
index d55c5259..ec1de234 100644
--- a/lib/libalpm/po/uk.po
+++ b/lib/libalpm/po/uk.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: toofishes <dpmcgee@gmail.com>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
@@ -154,6 +154,10 @@ msgstr "бракує метаданих пакунку в %s\n"
msgid "removing invalid file: %s\n"
msgstr ""
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "неможливо розібрати файл опису пакунка %s\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "шлях до бази даних не вказано\n"
@@ -219,18 +223,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "не вдалося отримати файл '%s' з %s : %s\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "неможливо продовжити завантаження %s; починається з початку\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "помилка при запису до файлу '%s': %s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "не вдалося отримати файл '%s' з %s\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "здається %s обрізаний: %jd/%jd байтів\n"
@@ -379,6 +371,18 @@ msgid "could not find repository for target"
msgstr "неможливо знайти репозиторій з пакунком"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "невірний чи пошкоджений дельта-патч"
@@ -403,10 +407,6 @@ msgid "failed to retrieve some files"
msgstr "не вдалося отримати деякі файли"
#, c-format
-msgid "failed to copy some file"
-msgstr ""
-
-#, c-format
msgid "invalid regular expression"
msgstr "невірний регулярний вираз"
@@ -419,6 +419,10 @@ msgid "download library error"
msgstr "помилка бібліотеки завантаження"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "помилка виклику зовнішнього завантажувача"
@@ -427,10 +431,6 @@ msgid "unexpected error"
msgstr "неочікувана помилка"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr ""
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "неможливо знайти %s в базі даних -- пропускається\n"
@@ -549,3 +549,12 @@ msgstr "кеш %s не існує, створюється...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "неможливо створити кеш пакунку, використовуватиметься /tmp\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "неможливо продовжити завантаження %s; починається з початку\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "помилка при запису до файлу '%s': %s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "не вдалося отримати файл '%s' з %s\n"
diff --git a/lib/libalpm/po/zh_CN.po b/lib/libalpm/po/zh_CN.po
index d3844477..3b07ac07 100644
--- a/lib/libalpm/po/zh_CN.po
+++ b/lib/libalpm/po/zh_CN.po
@@ -7,7 +7,7 @@ msgid ""
msgstr ""
"Project-Id-Version: Arch Linux Pacman package manager\n"
"Report-Msgid-Bugs-To: http://bugs.archlinux.org/index.php?project=3\n"
-"POT-Creation-Date: 2011-04-18 11:23-0500\n"
+"POT-Creation-Date: 2011-06-23 21:48-0500\n"
"PO-Revision-Date: 2011-03-22 15:34+0000\n"
"Last-Translator: ganlu <rhythm.gan@gmail.com>\n"
"Language-Team: Chinese (China) <None>\n"
@@ -153,6 +153,10 @@ msgstr "%s 中缺少软件包元数据\n"
msgid "removing invalid file: %s\n"
msgstr "删除无效文件: %s\n"
+#, fuzzy, c-format
+msgid "could not parse package '%s' description file from db '%s'\n"
+msgstr "无法解析 %s 中的软件包描述文件\n"
+
#, c-format
msgid "database path is undefined\n"
msgstr "数据库路径未定义\n"
@@ -220,18 +224,6 @@ msgid "failed retrieving file '%s' from %s : %s\n"
msgstr "无法从 %2$s : %3$s 获取文件 '%1$s'\n"
#, c-format
-msgid "resuming download of %s not possible; starting over\n"
-msgstr "无法恢复下载 %s;正在重新开始\n"
-
-#, c-format
-msgid "error writing to file '%s': %s\n"
-msgstr "写入文件 '%1$s' 时出错: %2$s\n"
-
-#, c-format
-msgid "failed retrieving file '%s' from %s\n"
-msgstr "无法从 %2$s 获取文件 '%1$s'\n"
-
-#, c-format
msgid "%s appears to be truncated: %jd/%jd bytes\n"
msgstr "%s 可缩小:%jd/%jd bytes\n"
@@ -380,6 +372,18 @@ msgid "could not find repository for target"
msgstr "无法为目标找到软件库"
#, c-format
+msgid "signature directory not configured correctly"
+msgstr ""
+
+#, c-format
+msgid "invalid PGP signature"
+msgstr ""
+
+#, c-format
+msgid "unknown PGP signature"
+msgstr ""
+
+#, c-format
msgid "invalid or corrupted delta"
msgstr "无效的或已损坏的 delta"
@@ -404,10 +408,6 @@ msgid "failed to retrieve some files"
msgstr "无法获取某些文件"
#, c-format
-msgid "failed to copy some file"
-msgstr "复制文件失败"
-
-#, c-format
msgid "invalid regular expression"
msgstr "无效的正则表达式"
@@ -420,6 +420,10 @@ msgid "download library error"
msgstr "下载函数库出错"
#, c-format
+msgid "gpgme error"
+msgstr ""
+
+#, c-format
msgid "error invoking external downloader"
msgstr "调用外部下载程序时出错"
@@ -428,10 +432,6 @@ msgid "unexpected error"
msgstr "未预期的错误"
#, c-format
-msgid "database larger than maximum size\n"
-msgstr "数据库超过最大支持的大小\n"
-
-#, c-format
msgid "could not find %s in database -- skipping\n"
msgstr "无法在数据库中找到 %s -- 跳过\n"
@@ -550,3 +550,18 @@ msgstr "没有 %s 缓存存在,正在创建...\n"
#, c-format
msgid "couldn't create package cache, using /tmp instead\n"
msgstr "无法创建软件包缓存,正在使用 /tmp 代替\n"
+
+#~ msgid "resuming download of %s not possible; starting over\n"
+#~ msgstr "无法恢复下载 %s;正在重新开始\n"
+
+#~ msgid "error writing to file '%s': %s\n"
+#~ msgstr "写入文件 '%1$s' 时出错: %2$s\n"
+
+#~ msgid "failed retrieving file '%s' from %s\n"
+#~ msgstr "无法从 %2$s 获取文件 '%1$s'\n"
+
+#~ msgid "failed to copy some file"
+#~ msgstr "复制文件失败"
+
+#~ msgid "database larger than maximum size\n"
+#~ msgstr "数据库超过最大支持的大小\n"
diff --git a/lib/libalpm/rawstr.c b/lib/libalpm/rawstr.c
new file mode 100644
index 00000000..86f4280c
--- /dev/null
+++ b/lib/libalpm/rawstr.c
@@ -0,0 +1,137 @@
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* These functions are borrowed from libcurl's lib/rawstr.c with minor
+ * modifications to style and naming. Curl_raw_equal and Curl_raw_nequal are
+ * further modified to be true cmp style functions, returning negative, zero,
+ * or positive. */
+
+#include <stdlib.h>
+
+#include "util.h"
+
+/* Portable, consistent toupper (remember EBCDIC). Do not use toupper() because
+ its behavior is altered by the current locale. */
+static char raw_toupper(char in)
+{
+ switch(in) {
+ case 'a':
+ return 'A';
+ case 'b':
+ return 'B';
+ case 'c':
+ return 'C';
+ case 'd':
+ return 'D';
+ case 'e':
+ return 'E';
+ case 'f':
+ return 'F';
+ case 'g':
+ return 'G';
+ case 'h':
+ return 'H';
+ case 'i':
+ return 'I';
+ case 'j':
+ return 'J';
+ case 'k':
+ return 'K';
+ case 'l':
+ return 'L';
+ case 'm':
+ return 'M';
+ case 'n':
+ return 'N';
+ case 'o':
+ return 'O';
+ case 'p':
+ return 'P';
+ case 'q':
+ return 'Q';
+ case 'r':
+ return 'R';
+ case 's':
+ return 'S';
+ case 't':
+ return 'T';
+ case 'u':
+ return 'U';
+ case 'v':
+ return 'V';
+ case 'w':
+ return 'W';
+ case 'x':
+ return 'X';
+ case 'y':
+ return 'Y';
+ case 'z':
+ return 'Z';
+ }
+ return in;
+}
+
+/*
+ * _alpm_raw_cmp() is for doing "raw" case insensitive strings. This is meant
+ * to be locale independent and only compare strings we know are safe for
+ * this. See http://daniel.haxx.se/blog/2008/10/15/strcasecmp-in-turkish/ for
+ * some further explanation to why this function is necessary.
+ *
+ * The function is capable of comparing a-z case insensitively even for
+ * non-ascii.
+ */
+
+int _alpm_raw_cmp(const char *first, const char *second)
+{
+ while(*first && *second) {
+ if(raw_toupper(*first) != raw_toupper(*second)) {
+ /* get out of the loop as soon as they don't match */
+ break;
+ }
+ first++;
+ second++;
+ }
+ /* we do the comparison here (possibly again), just to make sure that if the
+ loop above is skipped because one of the strings reached zero, we must not
+ return this as a successful match */
+ return (raw_toupper(*first) - raw_toupper(*second));
+}
+
+int _alpm_raw_ncmp(const char *first, const char *second, size_t max)
+{
+ while(*first && *second && max) {
+ if(raw_toupper(*first) != raw_toupper(*second)) {
+ break;
+ }
+ max--;
+ first++;
+ second++;
+ }
+ if(0 == max) {
+ /* they are equal this far */
+ return 0;
+ }
+
+ return (raw_toupper(*first) - raw_toupper(*second));
+}
+
+/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/remove.c b/lib/libalpm/remove.c
index 22ae2bb8..3c19c90a 100644
--- a/lib/libalpm/remove.c
+++ b/lib/libalpm/remove.c
@@ -26,8 +26,6 @@
#include <stdlib.h>
#include <errno.h>
-#include <time.h>
-#include <fcntl.h>
#include <string.h>
#include <limits.h>
#include <unistd.h>
@@ -36,6 +34,7 @@
/* libalpm */
#include "remove.h"
#include "alpm_list.h"
+#include "alpm.h"
#include "trans.h"
#include "util.h"
#include "log.h"
@@ -44,73 +43,72 @@
#include "db.h"
#include "deps.h"
#include "handle.h"
-#include "alpm.h"
+#include "conflict.h"
-int SYMEXPORT alpm_remove_pkg(pmpkg_t *pkg)
+int SYMEXPORT alpm_remove_pkg(alpm_handle_t *handle, alpm_pkg_t *pkg)
{
- pmtrans_t *trans;
const char *pkgname;
-
- ALPM_LOG_FUNC;
+ alpm_trans_t *trans;
/* Sanity checks */
- ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
+ ASSERT(pkg != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
+ ASSERT(handle == pkg->handle, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
trans = handle->trans;
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
+ ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
ASSERT(trans->state == STATE_INITIALIZED,
- RET_ERR(PM_ERR_TRANS_NOT_INITIALIZED, -1));
+ RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1));
- pkgname = alpm_pkg_get_name(pkg);
+ pkgname = pkg->name;
if(_alpm_pkg_find(trans->remove, pkgname)) {
- RET_ERR(PM_ERR_TRANS_DUP_TARGET, -1);
+ RET_ERR(handle, ALPM_ERR_TRANS_DUP_TARGET, -1);
}
- _alpm_log(PM_LOG_DEBUG, "adding %s in the target list\n", pkgname);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s to the transaction remove list\n",
+ pkgname);
trans->remove = alpm_list_add(trans->remove, _alpm_pkg_dup(pkg));
- return(0);
+ return 0;
}
-static void remove_prepare_cascade(pmtrans_t *trans, pmdb_t *db,
- alpm_list_t *lp)
+static void remove_prepare_cascade(alpm_handle_t *handle, alpm_list_t *lp)
{
- ALPM_LOG_FUNC;
+ alpm_trans_t *trans = handle->trans;
while(lp) {
alpm_list_t *i;
for(i = lp; i; i = i->next) {
- pmdepmissing_t *miss = (pmdepmissing_t *)i->data;
- pmpkg_t *info = _alpm_db_get_pkgfromcache(db, miss->target);
+ alpm_depmissing_t *miss = i->data;
+ alpm_pkg_t *info = _alpm_db_get_pkgfromcache(handle->db_local, miss->target);
if(info) {
if(!_alpm_pkg_find(trans->remove, alpm_pkg_get_name(info))) {
- _alpm_log(PM_LOG_DEBUG, "pulling %s in target list\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "pulling %s in target list\n",
alpm_pkg_get_name(info));
trans->remove = alpm_list_add(trans->remove, _alpm_pkg_dup(info));
}
} else {
- _alpm_log(PM_LOG_ERROR, _("could not find %s in database -- skipping\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not find %s in database -- skipping\n"),
miss->target);
}
}
alpm_list_free_inner(lp, (alpm_list_fn_free)_alpm_depmiss_free);
alpm_list_free(lp);
- lp = alpm_checkdeps(_alpm_db_get_pkgcache(db), 1, trans->remove, NULL);
+ lp = alpm_checkdeps(handle, _alpm_db_get_pkgcache(handle->db_local),
+ trans->remove, NULL, 1);
}
}
-static void remove_prepare_keep_needed(pmtrans_t *trans, pmdb_t *db,
- alpm_list_t *lp)
+static void remove_prepare_keep_needed(alpm_handle_t *handle, alpm_list_t *lp)
{
- ALPM_LOG_FUNC;
+ alpm_trans_t *trans = handle->trans;
/* Remove needed packages (which break dependencies) from target list */
while(lp != NULL) {
alpm_list_t *i;
for(i = lp; i; i = i->next) {
- pmdepmissing_t *miss = (pmdepmissing_t *)i->data;
+ alpm_depmissing_t *miss = i->data;
void *vpkg;
- pmpkg_t *pkg = _alpm_pkg_find(trans->remove, miss->causingpkg);
+ alpm_pkg_t *pkg = _alpm_pkg_find(trans->remove, miss->causingpkg);
if(pkg == NULL) {
continue;
}
@@ -118,52 +116,50 @@ static void remove_prepare_keep_needed(pmtrans_t *trans, pmdb_t *db,
&vpkg);
pkg = vpkg;
if(pkg) {
- _alpm_log(PM_LOG_WARNING, _("removing %s from target list\n"),
+ _alpm_log(handle, ALPM_LOG_WARNING, _("removing %s from target list\n"),
alpm_pkg_get_name(pkg));
_alpm_pkg_free(pkg);
}
}
alpm_list_free_inner(lp, (alpm_list_fn_free)_alpm_depmiss_free);
alpm_list_free(lp);
- lp = alpm_checkdeps(_alpm_db_get_pkgcache(db), 1, trans->remove, NULL);
+ lp = alpm_checkdeps(handle, _alpm_db_get_pkgcache(handle->db_local),
+ trans->remove, NULL, 1);
}
}
/** Transaction preparation for remove actions.
* This functions takes a pointer to a alpm_list_t which will be
- * filled with a list of pmdepmissing_t* objects representing
+ * filled with a list of alpm_depmissing_t* objects representing
* the packages blocking the transaction.
- * @param trans the transaction object
- * @param db the database of local packages
+ * @param handle the context handle
* @param data a pointer to an alpm_list_t* to fill
*/
-int _alpm_remove_prepare(pmtrans_t *trans, pmdb_t *db, alpm_list_t **data)
+int _alpm_remove_prepare(alpm_handle_t *handle, alpm_list_t **data)
{
alpm_list_t *lp;
+ alpm_trans_t *trans = handle->trans;
+ alpm_db_t *db = handle->db_local;
- ALPM_LOG_FUNC;
-
- ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
-
- if((trans->flags & PM_TRANS_FLAG_RECURSE) && !(trans->flags & PM_TRANS_FLAG_CASCADE)) {
- _alpm_log(PM_LOG_DEBUG, "finding removable dependencies\n");
- _alpm_recursedeps(db, trans->remove, trans->flags & PM_TRANS_FLAG_RECURSEALL);
+ if((trans->flags & ALPM_TRANS_FLAG_RECURSE) && !(trans->flags & ALPM_TRANS_FLAG_CASCADE)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "finding removable dependencies\n");
+ _alpm_recursedeps(db, trans->remove,
+ trans->flags & ALPM_TRANS_FLAG_RECURSEALL);
}
- if(!(trans->flags & PM_TRANS_FLAG_NODEPS)) {
- EVENT(trans, PM_TRANS_EVT_CHECKDEPS_START, NULL, NULL);
+ if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) {
+ EVENT(trans, ALPM_TRANS_EVT_CHECKDEPS_START, NULL, NULL);
- _alpm_log(PM_LOG_DEBUG, "looking for unsatisfied dependencies\n");
- lp = alpm_checkdeps(_alpm_db_get_pkgcache(db), 1, trans->remove, NULL);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "looking for unsatisfied dependencies\n");
+ lp = alpm_checkdeps(handle, _alpm_db_get_pkgcache(db), trans->remove, NULL, 1);
if(lp != NULL) {
- if(trans->flags & PM_TRANS_FLAG_CASCADE) {
- remove_prepare_cascade(trans, db, lp);
- } else if (trans->flags & PM_TRANS_FLAG_UNNEEDED) {
+ if(trans->flags & ALPM_TRANS_FLAG_CASCADE) {
+ remove_prepare_cascade(handle, lp);
+ } else if(trans->flags & ALPM_TRANS_FLAG_UNNEEDED) {
/* Remove needed packages (which would break dependencies)
* from target list */
- remove_prepare_keep_needed(trans, db, lp);
+ remove_prepare_keep_needed(handle, lp);
} else {
if(data) {
*data = lp;
@@ -171,74 +167,74 @@ int _alpm_remove_prepare(pmtrans_t *trans, pmdb_t *db, alpm_list_t **data)
alpm_list_free_inner(lp, (alpm_list_fn_free)_alpm_depmiss_free);
alpm_list_free(lp);
}
- RET_ERR(PM_ERR_UNSATISFIED_DEPS, -1);
+ RET_ERR(handle, ALPM_ERR_UNSATISFIED_DEPS, -1);
}
}
}
/* re-order w.r.t. dependencies */
- _alpm_log(PM_LOG_DEBUG, "sorting by dependencies\n");
- lp = _alpm_sortbydeps(trans->remove, 1);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "sorting by dependencies\n");
+ lp = _alpm_sortbydeps(handle, trans->remove, 1);
/* free the old alltargs */
alpm_list_free(trans->remove);
trans->remove = lp;
/* -Rcs == -Rc then -Rs */
- if((trans->flags & PM_TRANS_FLAG_CASCADE) && (trans->flags & PM_TRANS_FLAG_RECURSE)) {
- _alpm_log(PM_LOG_DEBUG, "finding removable dependencies\n");
- _alpm_recursedeps(db, trans->remove, trans->flags & PM_TRANS_FLAG_RECURSEALL);
+ if((trans->flags & ALPM_TRANS_FLAG_CASCADE) && (trans->flags & ALPM_TRANS_FLAG_RECURSE)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "finding removable dependencies\n");
+ _alpm_recursedeps(db, trans->remove, trans->flags & ALPM_TRANS_FLAG_RECURSEALL);
}
- if(!(trans->flags & PM_TRANS_FLAG_NODEPS)) {
- EVENT(trans, PM_TRANS_EVT_CHECKDEPS_DONE, NULL, NULL);
+ if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) {
+ EVENT(trans, ALPM_TRANS_EVT_CHECKDEPS_DONE, NULL, NULL);
}
- return(0);
+ return 0;
}
-static int can_remove_file(const char *path, alpm_list_t *skip)
+static int can_remove_file(alpm_handle_t *handle, const alpm_file_t *file,
+ alpm_list_t *skip_remove)
{
- char file[PATH_MAX+1];
+ char filepath[PATH_MAX];
- snprintf(file, PATH_MAX, "%s%s", handle->root, path);
+ snprintf(filepath, PATH_MAX, "%s%s", handle->root, file->name);
- if(alpm_list_find_str(skip, file)) {
+ if(alpm_list_find_str(skip_remove, filepath)) {
/* return success because we will never actually remove this file */
- return(1);
+ return 1;
}
/* If we fail write permissions due to a read-only filesystem, abort.
* Assume all other possible failures are covered somewhere else */
- if(access(file, W_OK) == -1) {
- if(errno != EACCES && errno != ETXTBSY && access(file, F_OK) == 0) {
+ if(_alpm_access(handle, NULL, filepath, W_OK) == -1) {
+ if(errno != EACCES && errno != ETXTBSY && access(filepath, F_OK) == 0) {
/* only return failure if the file ACTUALLY exists and we can't write to
* it - ignore "chmod -w" simple permission failures */
- _alpm_log(PM_LOG_ERROR, _("cannot remove file '%s': %s\n"),
- file, strerror(errno));
- return(0);
+ _alpm_log(handle, ALPM_LOG_ERROR, _("cannot remove file '%s': %s\n"),
+ filepath, strerror(errno));
+ return 0;
}
}
- return(1);
+ return 1;
}
/* Helper function for iterating through a package's file and deleting them
* Used by _alpm_remove_commit. */
-static void unlink_file(pmpkg_t *info, char *filename, alpm_list_t *skip_remove, int nosave)
+static int unlink_file(alpm_handle_t *handle, alpm_pkg_t *info,
+ const alpm_file_t *fileobj, alpm_list_t *skip_remove, int nosave)
{
struct stat buf;
- char file[PATH_MAX+1];
-
- ALPM_LOG_FUNC;
+ char file[PATH_MAX];
- snprintf(file, PATH_MAX, "%s%s", handle->root, filename);
+ snprintf(file, PATH_MAX, "%s%s", handle->root, fileobj->name);
/* check the remove skip list before removing the file.
* see the big comment block in db_find_fileconflicts() for an
* explanation. */
- if(alpm_list_find_str(skip_remove, filename)) {
- _alpm_log(PM_LOG_DEBUG, "%s is in skip_remove, skipping removal\n",
- file);
- return;
+ if(alpm_list_find_str(skip_remove, fileobj->name)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "%s is in skip_remove, skipping removal\n", file);
+ return 1;
}
/* we want to do a lstat here, and not a _alpm_lstat.
@@ -246,226 +242,252 @@ static void unlink_file(pmpkg_t *info, char *filename, alpm_list_t *skip_remove,
* filesystem, we want to work with the linked directory instead of the
* actual symlink */
if(lstat(file, &buf)) {
- _alpm_log(PM_LOG_DEBUG, "file %s does not exist\n", file);
- return;
+ _alpm_log(handle, ALPM_LOG_DEBUG, "file %s does not exist\n", file);
+ return 1;
}
if(S_ISDIR(buf.st_mode)) {
- if(rmdir(file)) {
- /* this is okay, other packages are probably using it (like /usr) */
- _alpm_log(PM_LOG_DEBUG, "keeping directory %s\n", file);
+ ssize_t files = _alpm_files_in_directory(handle, file, 0);
+ /* if we have files, no need to remove the directory */
+ if(files > 0) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "keeping directory %s (contains files)\n",
+ file);
+ } else if(files < 0) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "keeping directory %s (could not count files)\n", file);
} else {
- _alpm_log(PM_LOG_DEBUG, "removing directory %s\n", file);
+ /* one last check- does any other package own this file? */
+ alpm_list_t *local, *local_pkgs;
+ int found = 0;
+ local_pkgs = _alpm_db_get_pkgcache(handle->db_local);
+ for(local = local_pkgs; local && !found; local = local->next) {
+ alpm_pkg_t *local_pkg = local->data;
+ alpm_filelist_t *filelist;
+
+ /* we duplicated the package when we put it in the removal list, so we
+ * so we can't use direct pointer comparison here. */
+ if(_alpm_pkg_cmp(info, local_pkg) == 0) {
+ continue;
+ }
+ filelist = alpm_pkg_get_files(local_pkg);
+ if(_alpm_filelist_contains(filelist, fileobj->name)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "keeping directory %s (owned by %s)\n", file, local_pkg->name);
+ found = 1;
+ }
+ }
+ if(!found) {
+ if(rmdir(file)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "directory removal of %s failed: %s\n", file, strerror(errno));
+ return -1;
+ } else {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "removed directory %s (no remaining owners)\n", file);
+ }
+ }
}
} else {
/* if the file needs backup and has been modified, back it up to .pacsave */
- char *pkghash = _alpm_needbackup(filename, alpm_pkg_get_backup(info));
- if(pkghash) {
+ alpm_backup_t *backup = _alpm_needbackup(fileobj->name, info);
+ if(backup) {
if(nosave) {
- _alpm_log(PM_LOG_DEBUG, "transaction is set to NOSAVE, not backing up '%s'\n", file);
- FREE(pkghash);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "transaction is set to NOSAVE, not backing up '%s'\n", file);
} else {
char *filehash = alpm_compute_md5sum(file);
- int cmp = filehash ? strcmp(filehash, pkghash) : 0;
+ int cmp = filehash ? strcmp(filehash, backup->hash) : 0;
FREE(filehash);
- FREE(pkghash);
if(cmp != 0) {
char newpath[PATH_MAX];
snprintf(newpath, PATH_MAX, "%s.pacsave", file);
- rename(file, newpath);
- _alpm_log(PM_LOG_WARNING, _("%s saved as %s\n"), file, newpath);
- alpm_logaction("warning: %s saved as %s\n", file, newpath);
- return;
+ if(rename(file, newpath)) {
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
+ file, newpath, strerror(errno));
+ alpm_logaction(handle, "error: could not rename %s to %s (%s)\n",
+ file, newpath, strerror(errno));
+ return -1;
+ }
+ _alpm_log(handle, ALPM_LOG_WARNING, _("%s saved as %s\n"), file, newpath);
+ alpm_logaction(handle, "warning: %s saved as %s\n", file, newpath);
+ return 0;
}
}
}
- _alpm_log(PM_LOG_DEBUG, "unlinking %s\n", file);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "unlinking %s\n", file);
if(unlink(file) == -1) {
- _alpm_log(PM_LOG_ERROR, _("cannot remove file '%s': %s\n"),
- filename, strerror(errno));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("cannot remove %s (%s)\n"),
+ file, strerror(errno));
+ alpm_logaction(handle, "error: cannot remove %s (%s)\n",
+ file, strerror(errno));
+ return -1;
}
}
+ return 0;
}
-int _alpm_upgraderemove_package(pmpkg_t *oldpkg, pmpkg_t *newpkg,
- pmtrans_t *trans)
+int _alpm_remove_single_package(alpm_handle_t *handle,
+ alpm_pkg_t *oldpkg, alpm_pkg_t *newpkg,
+ size_t targ_count, size_t pkg_count)
{
- alpm_list_t *skip_remove, *b;
- alpm_list_t *newfiles, *lp;
- size_t filenum;
- alpm_list_t *files = alpm_pkg_get_files(oldpkg);
- const char *pkgname = alpm_pkg_get_name(oldpkg);
+ alpm_list_t *skip_remove;
+ size_t filenum = 0, position = 0;
+ const char *pkgname = oldpkg->name;
+ const char *pkgver = oldpkg->version;
+ alpm_filelist_t *filelist;
+ char scriptlet[PATH_MAX];
+ size_t i;
+
+ if(newpkg) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "removing old package first (%s-%s)\n",
+ pkgname, pkgver);
+ } else {
+ EVENT(handle->trans, ALPM_TRANS_EVT_REMOVE_START, oldpkg, NULL);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "removing package %s-%s\n",
+ pkgname, pkgver);
- ALPM_LOG_FUNC;
+ snprintf(scriptlet, PATH_MAX, "%s%s-%s/install",
+ _alpm_db_path(handle->db_local), pkgname, pkgver);
- _alpm_log(PM_LOG_DEBUG, "removing old package first (%s-%s)\n",
- oldpkg->name, oldpkg->version);
+ /* run the pre-remove scriptlet if it exists */
+ if(alpm_pkg_has_scriptlet(oldpkg) &&
+ !(handle->trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
+ _alpm_runscriptlet(handle, scriptlet, "pre_remove", pkgver, NULL);
+ }
+ }
- if(trans->flags & PM_TRANS_FLAG_DBONLY) {
+ if(handle->trans->flags & ALPM_TRANS_FLAG_DBONLY) {
goto db;
}
- /* copy the remove skiplist over */
- skip_remove = alpm_list_join(
- alpm_list_strdup(trans->skip_remove),
- alpm_list_strdup(handle->noupgrade));
- /* Add files in the NEW backup array to the skip_remove array
- * so this removal operation doesn't kill them */
- /* old package backup list */
- alpm_list_t *filelist = alpm_pkg_get_files(newpkg);
- for(b = alpm_pkg_get_backup(newpkg); b; b = b->next) {
- char *backup = _alpm_backup_file(b->data);
- /* safety check (fix the upgrade026 pactest) */
- if(!alpm_list_find_str(filelist, backup)) {
- FREE(backup);
- continue;
+ if(newpkg) {
+ alpm_filelist_t *newfiles;
+ alpm_list_t *b;
+ skip_remove = alpm_list_join(
+ alpm_list_strdup(handle->trans->skip_remove),
+ alpm_list_strdup(handle->noupgrade));
+ /* Add files in the NEW backup array to the skip_remove array
+ * so this removal operation doesn't kill them */
+ /* old package backup list */
+ newfiles = alpm_pkg_get_files(newpkg);
+ for(b = alpm_pkg_get_backup(newpkg); b; b = b->next) {
+ const alpm_backup_t *backup = b->data;
+ /* safety check (fix the upgrade026 pactest) */
+ if(!_alpm_filelist_contains(newfiles, backup->name)) {
+ continue;
+ }
+ _alpm_log(handle, ALPM_LOG_DEBUG, "adding %s to the skip_remove array\n",
+ backup->name);
+ skip_remove = alpm_list_add(skip_remove, strdup(backup->name));
}
- _alpm_log(PM_LOG_DEBUG, "adding %s to the skip_remove array\n", backup);
- skip_remove = alpm_list_add(skip_remove, backup);
+ } else {
+ skip_remove = alpm_list_strdup(handle->trans->skip_remove);
}
- for(lp = files; lp; lp = lp->next) {
- if(!can_remove_file(lp->data, skip_remove)) {
- _alpm_log(PM_LOG_DEBUG, "not removing package '%s', can't remove all files\n",
- pkgname);
- RET_ERR(PM_ERR_PKG_CANT_REMOVE, -1);
+ filelist = alpm_pkg_get_files(oldpkg);
+ for(i = 0; i < filelist->count; i++) {
+ alpm_file_t *file = filelist->files + i;
+ if(!can_remove_file(handle, file, skip_remove)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "not removing package '%s', can't remove all files\n", pkgname);
+ RET_ERR(handle, ALPM_ERR_PKG_CANT_REMOVE, -1);
}
+ filenum++;
}
- filenum = alpm_list_count(files);
- _alpm_log(PM_LOG_DEBUG, "removing %ld files\n", (unsigned long)filenum);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "removing %ld files\n", (unsigned long)filenum);
+
+ if(!newpkg) {
+ /* init progress bar, but only on true remove transactions */
+ PROGRESS(handle->trans, ALPM_TRANS_PROGRESS_REMOVE_START, pkgname, 0,
+ pkg_count, targ_count);
+ }
/* iterate through the list backwards, unlinking files */
- newfiles = alpm_list_reverse(files);
- for(lp = newfiles; lp; lp = alpm_list_next(lp)) {
- unlink_file(oldpkg, lp->data, skip_remove, 0);
+ for(i = filelist->count; i > 0; i--) {
+ alpm_file_t *file = filelist->files + i - 1;
+ int percent;
+ /* TODO: check return code and handle accordingly */
+ unlink_file(handle, oldpkg, file, skip_remove,
+ handle->trans->flags & ALPM_TRANS_FLAG_NOSAVE);
+
+ if(!newpkg) {
+ /* update progress bar after each file */
+ percent = (position * 100) / filenum;
+ PROGRESS(handle->trans, ALPM_TRANS_PROGRESS_REMOVE_START, pkgname,
+ percent, pkg_count, targ_count);
+ }
+ position++;
}
- alpm_list_free(newfiles);
FREELIST(skip_remove);
+ if(!newpkg) {
+ /* set progress to 100% after we finish unlinking files */
+ PROGRESS(handle->trans, ALPM_TRANS_PROGRESS_REMOVE_START, pkgname, 100,
+ pkg_count, targ_count);
+
+ /* run the post-remove script if it exists */
+ if(alpm_pkg_has_scriptlet(oldpkg) &&
+ !(handle->trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
+ _alpm_runscriptlet(handle, scriptlet, "post_remove", pkgver, NULL);
+ }
+ }
+
db:
/* remove the package from the database */
- _alpm_log(PM_LOG_DEBUG, "updating database\n");
- _alpm_log(PM_LOG_DEBUG, "removing database entry '%s'\n", pkgname);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "updating database\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "removing database entry '%s'\n", pkgname);
if(_alpm_local_db_remove(handle->db_local, oldpkg) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not remove database entry %s-%s\n"),
- pkgname, alpm_pkg_get_version(oldpkg));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not remove database entry %s-%s\n"),
+ pkgname, pkgver);
}
/* remove the package from the cache */
if(_alpm_db_remove_pkgfromcache(handle->db_local, oldpkg) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not remove entry '%s' from cache\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not remove entry '%s' from cache\n"),
pkgname);
}
- return(0);
+ if(!newpkg) {
+ /* TODO: awesome! we're passing invalid pointers. */
+ EVENT(handle->trans, ALPM_TRANS_EVT_REMOVE_DONE, oldpkg, NULL);
+ }
+
+ return 0;
}
-int _alpm_remove_packages(pmtrans_t *trans, pmdb_t *db)
+int _alpm_remove_packages(alpm_handle_t *handle)
{
- pmpkg_t *info;
- alpm_list_t *targ, *lp;
- size_t pkg_count;
-
- ALPM_LOG_FUNC;
-
- ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
+ alpm_list_t *targ;
+ size_t pkg_count, targ_count;
+ alpm_trans_t *trans = handle->trans;
+ int ret = 0;
pkg_count = alpm_list_count(trans->remove);
+ targ_count = 1;
for(targ = trans->remove; targ; targ = targ->next) {
- int position = 0;
- char scriptlet[PATH_MAX];
- info = (pmpkg_t*)targ->data;
- const char *pkgname = NULL;
- size_t targcount = alpm_list_count(targ);
-
- if(handle->trans->state == STATE_INTERRUPTED) {
- return(0);
- }
+ alpm_pkg_t *pkg = targ->data;
- /* get the name now so we can use it after package is removed */
- pkgname = alpm_pkg_get_name(info);
- snprintf(scriptlet, PATH_MAX, "%s%s-%s/install",
- _alpm_db_path(db), pkgname, alpm_pkg_get_version(info));
-
- EVENT(trans, PM_TRANS_EVT_REMOVE_START, info, NULL);
- _alpm_log(PM_LOG_DEBUG, "removing package %s-%s\n",
- pkgname, alpm_pkg_get_version(info));
-
- /* run the pre-remove scriptlet if it exists */
- if(alpm_pkg_has_scriptlet(info) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
- _alpm_runscriptlet(handle->root, scriptlet, "pre_remove",
- alpm_pkg_get_version(info), NULL, trans);
+ if(trans->state == STATE_INTERRUPTED) {
+ return 0;
}
- if(!(trans->flags & PM_TRANS_FLAG_DBONLY)) {
- alpm_list_t *files = alpm_pkg_get_files(info);
- alpm_list_t *newfiles;
- size_t filenum;
-
- for(lp = files; lp; lp = lp->next) {
- if(!can_remove_file(lp->data, NULL)) {
- _alpm_log(PM_LOG_DEBUG, "not removing package '%s', can't remove all files\n",
- pkgname);
- RET_ERR(PM_ERR_PKG_CANT_REMOVE, -1);
- }
- }
-
- filenum = alpm_list_count(files);
- _alpm_log(PM_LOG_DEBUG, "removing %ld files\n", (unsigned long)filenum);
-
- /* init progress bar */
- PROGRESS(trans, PM_TRANS_PROGRESS_REMOVE_START, info->name, 0,
- pkg_count, (pkg_count - targcount + 1));
-
- /* iterate through the list backwards, unlinking files */
- newfiles = alpm_list_reverse(files);
- for(lp = newfiles; lp; lp = alpm_list_next(lp)) {
- int percent;
- unlink_file(info, lp->data, NULL, trans->flags & PM_TRANS_FLAG_NOSAVE);
-
- /* update progress bar after each file */
- percent = (position * 100) / filenum;
- PROGRESS(trans, PM_TRANS_PROGRESS_REMOVE_START, info->name,
- percent, pkg_count, (pkg_count - targcount + 1));
- position++;
- }
- alpm_list_free(newfiles);
- }
-
- /* set progress to 100% after we finish unlinking files */
- PROGRESS(trans, PM_TRANS_PROGRESS_REMOVE_START, pkgname, 100,
- pkg_count, (pkg_count - targcount + 1));
-
- /* run the post-remove script if it exists */
- if(alpm_pkg_has_scriptlet(info) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
- _alpm_runscriptlet(handle->root, scriptlet, "post_remove",
- alpm_pkg_get_version(info), NULL, trans);
- }
-
- /* remove the package from the database */
- _alpm_log(PM_LOG_DEBUG, "updating database\n");
- _alpm_log(PM_LOG_DEBUG, "removing database entry '%s'\n", pkgname);
- if(_alpm_local_db_remove(db, info) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not remove database entry %s-%s\n"),
- pkgname, alpm_pkg_get_version(info));
- }
- /* remove the package from the cache */
- if(_alpm_db_remove_pkgfromcache(db, info) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not remove entry '%s' from cache\n"),
- pkgname);
+ if(_alpm_remove_single_package(handle, pkg, NULL,
+ targ_count, pkg_count) == -1) {
+ handle->pm_errno = ALPM_ERR_TRANS_ABORT;
+ ret = -1;
+ goto cleanup;
}
- EVENT(trans, PM_TRANS_EVT_REMOVE_DONE, info, NULL);
+ targ_count++;
}
/* run ldconfig if it exists */
- _alpm_ldconfig(handle->root);
+ _alpm_ldconfig(handle);
- return(0);
+cleanup:
+ return ret;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/remove.h b/lib/libalpm/remove.h
index a67e37a1..5da645b0 100644
--- a/lib/libalpm/remove.h
+++ b/lib/libalpm/remove.h
@@ -24,10 +24,12 @@
#include "alpm_list.h"
#include "trans.h"
-int _alpm_remove_prepare(pmtrans_t *trans, pmdb_t *db, alpm_list_t **data);
-int _alpm_remove_packages(pmtrans_t *trans, pmdb_t *db);
+int _alpm_remove_prepare(alpm_handle_t *handle, alpm_list_t **data);
+int _alpm_remove_packages(alpm_handle_t *handle);
-int _alpm_upgraderemove_package(pmpkg_t *oldpkg, pmpkg_t *newpkg, pmtrans_t *trans);
+int _alpm_remove_single_package(alpm_handle_t *handle,
+ alpm_pkg_t *oldpkg, alpm_pkg_t *newpkg,
+ size_t targ_count, size_t pkg_count);
#endif /* _ALPM_REMOVE_H */
diff --git a/lib/libalpm/signing.c b/lib/libalpm/signing.c
new file mode 100644
index 00000000..78e6264b
--- /dev/null
+++ b/lib/libalpm/signing.c
@@ -0,0 +1,548 @@
+/*
+ * signing.c
+ *
+ * Copyright (c) 2008-2011 Pacman Development Team <pacman-dev@archlinux.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 <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#if HAVE_LIBGPGME
+#include <locale.h> /* setlocale() */
+#include <gpgme.h>
+#include "base64.h"
+#endif
+
+/* libalpm */
+#include "signing.h"
+#include "package.h"
+#include "util.h"
+#include "log.h"
+#include "alpm.h"
+#include "handle.h"
+
+#if HAVE_LIBGPGME
+#define CHECK_ERR(void) do { \
+ if(gpg_err_code(err) != GPG_ERR_NO_ERROR) { goto error; } \
+ } while(0)
+
+static const char *string_validity(gpgme_validity_t validity)
+{
+ switch(validity) {
+ case GPGME_VALIDITY_UNKNOWN:
+ return "unknown";
+ case GPGME_VALIDITY_UNDEFINED:
+ return "undefined";
+ case GPGME_VALIDITY_NEVER:
+ return "never";
+ case GPGME_VALIDITY_MARGINAL:
+ return "marginal";
+ case GPGME_VALIDITY_FULL:
+ return "full";
+ case GPGME_VALIDITY_ULTIMATE:
+ return "ultimate";
+ }
+ return "???";
+}
+
+static void sigsum_test_bit(gpgme_sigsum_t sigsum, alpm_list_t **summary,
+ gpgme_sigsum_t bit, const char *value)
+{
+ if(sigsum & bit) {
+ *summary = alpm_list_add(*summary, (void *)value);
+ }
+}
+
+static alpm_list_t *list_sigsum(gpgme_sigsum_t sigsum)
+{
+ alpm_list_t *summary = NULL;
+ /* The docs say this can be a bitmask...not sure I believe it, but we'll code
+ * for it anyway and show all possible flags in the returned string. */
+
+ /* The signature is fully valid. */
+ sigsum_test_bit(sigsum, &summary, GPGME_SIGSUM_VALID, "valid");
+ /* The signature is good. */
+ sigsum_test_bit(sigsum, &summary, GPGME_SIGSUM_GREEN, "green");
+ /* The signature is bad. */
+ sigsum_test_bit(sigsum, &summary, GPGME_SIGSUM_RED, "red");
+ /* One key has been revoked. */
+ sigsum_test_bit(sigsum, &summary, GPGME_SIGSUM_KEY_REVOKED, "key revoked");
+ /* One key has expired. */
+ sigsum_test_bit(sigsum, &summary, GPGME_SIGSUM_KEY_EXPIRED, "key expired");
+ /* The signature has expired. */
+ sigsum_test_bit(sigsum, &summary, GPGME_SIGSUM_SIG_EXPIRED, "sig expired");
+ /* Can't verify: key missing. */
+ sigsum_test_bit(sigsum, &summary, GPGME_SIGSUM_KEY_MISSING, "key missing");
+ /* CRL not available. */
+ sigsum_test_bit(sigsum, &summary, GPGME_SIGSUM_CRL_MISSING, "crl missing");
+ /* Available CRL is too old. */
+ sigsum_test_bit(sigsum, &summary, GPGME_SIGSUM_CRL_TOO_OLD, "crl too old");
+ /* A policy was not met. */
+ sigsum_test_bit(sigsum, &summary, GPGME_SIGSUM_BAD_POLICY, "bad policy");
+ /* A system error occured. */
+ sigsum_test_bit(sigsum, &summary, GPGME_SIGSUM_SYS_ERROR, "sys error");
+ /* Fallback case */
+ if(!sigsum) {
+ summary = alpm_list_add(summary, (void *)"(empty)");
+ }
+ return summary;
+}
+
+static int init_gpgme(alpm_handle_t *handle)
+{
+ static int init = 0;
+ const char *version, *sigdir;
+ gpgme_error_t err;
+ gpgme_engine_info_t enginfo;
+
+ if(init) {
+ /* we already successfully initialized the library */
+ return 0;
+ }
+
+ sigdir = alpm_option_get_gpgdir(handle);
+
+ if (_alpm_access(handle, sigdir, "pubring.gpg", R_OK)
+ || _alpm_access(handle, sigdir, "trustdb.gpg", R_OK)) {
+ handle->pm_errno = ALPM_ERR_NOT_A_FILE;
+ _alpm_log(handle, ALPM_LOG_DEBUG, "Signature verification will fail!\n");
+ }
+
+ /* calling gpgme_check_version() returns the current version and runs
+ * some internal library setup code */
+ version = gpgme_check_version(NULL);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "GPGME version: %s\n", version);
+ gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
+#ifdef LC_MESSAGES
+ gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
+#endif
+ /* NOTE:
+ * The GPGME library installs a SIGPIPE signal handler automatically if
+ * the default signal hander is in use. The only time we set a handler
+ * for SIGPIPE is in dload.c, and we reset it when we are done. Given that
+ * we do this, we can let GPGME do its automagic. However, if we install
+ * a library-wide SIGPIPE handler, we will have to be careful.
+ */
+
+ /* check for OpenPGP support (should be a no-brainer, but be safe) */
+ err = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
+ CHECK_ERR();
+
+ /* set and check engine information */
+ err = gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP, NULL, sigdir);
+ CHECK_ERR();
+ err = gpgme_get_engine_info(&enginfo);
+ CHECK_ERR();
+ _alpm_log(handle, ALPM_LOG_DEBUG, "GPGME engine info: file=%s, home=%s\n",
+ enginfo->file_name, enginfo->home_dir);
+
+ init = 1;
+ return 0;
+
+error:
+ _alpm_log(handle, ALPM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(err));
+ RET_ERR(handle, ALPM_ERR_GPGME, 1);
+}
+
+/**
+ * Decode a loaded signature in base64 form.
+ * @param base64_data the signature to attempt to decode
+ * @param data the decoded data; must be freed by the caller
+ * @param data_len the length of the returned data
+ * @return 0 on success, 1 on failure to properly decode
+ */
+static int decode_signature(const char *base64_data,
+ unsigned char **data, int *data_len) {
+ unsigned char *usline;
+ int len;
+
+ len = strlen(base64_data);
+ usline = (unsigned char *)base64_data;
+ int ret, destlen = 0;
+ /* get the necessary size for the buffer by passing 0 */
+ ret = base64_decode(NULL, &destlen, usline, len);
+ if(ret != 0 && ret != POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL) {
+ goto error;
+ }
+ /* alloc our memory and repeat the call to decode */
+ MALLOC(*data, (size_t)destlen, goto error);
+ ret = base64_decode(*data, &destlen, usline, len);
+ if(ret != 0) {
+ goto error;
+ }
+ *data_len = destlen;
+ return 0;
+
+error:
+ *data = NULL;
+ *data_len = 0;
+ return 1;
+}
+
+/**
+ * Check the PGP signature for the given file path.
+ * If base64_sig is provided, it will be used as the signature data after
+ * decoding. If base64_sig is NULL, expect a signature file next to path
+ * (e.g. "%s.sig").
+ *
+ * The return value will be 0 if nothing abnormal happened during the signature
+ * check, and -1 if an error occurred while checking signatures or if a
+ * signature could not be found; pm_errno will be set. Note that "abnormal"
+ * does not include a failed signature; the value in #result should be checked
+ * to determine if the signature(s) are good.
+ * @param handle the context handle
+ * @param path the full path to a file
+ * @param base64_sig optional PGP signature data in base64 encoding
+ * @result
+ * @return 0 in normal cases, -1 if the something failed in the check process
+ */
+int _alpm_gpgme_checksig(alpm_handle_t *handle, const char *path,
+ const char *base64_sig, alpm_sigresult_t *result)
+{
+ int ret = -1, sigcount;
+ gpgme_error_t err;
+ gpgme_ctx_t ctx;
+ gpgme_data_t filedata, sigdata;
+ gpgme_verify_result_t verify_result;
+ gpgme_signature_t gpgsig;
+ char *sigpath = NULL;
+ unsigned char *decoded_sigdata = NULL;
+ FILE *file = NULL, *sigfile = NULL;
+
+ if(!path || _alpm_access(handle, NULL, path, R_OK) != 0) {
+ RET_ERR(handle, ALPM_ERR_NOT_A_FILE, -1);
+ }
+
+ if(!result) {
+ RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1);
+ }
+ result->count = 0;
+
+ if(!base64_sig) {
+ size_t len = strlen(path) + 5;
+ CALLOC(sigpath, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+ snprintf(sigpath, len, "%s.sig", path);
+
+ if(!_alpm_access(handle, NULL, sigpath, R_OK) == 0) {
+ /* sigcount is 0 */
+ }
+ }
+
+ if(init_gpgme(handle)) {
+ /* pm_errno was set in gpgme_init() */
+ return -1;
+ }
+
+ _alpm_log(handle, ALPM_LOG_DEBUG, "checking signature for %s\n", path);
+
+ memset(&ctx, 0, sizeof(ctx));
+ memset(&sigdata, 0, sizeof(sigdata));
+ memset(&filedata, 0, sizeof(filedata));
+
+ err = gpgme_new(&ctx);
+ CHECK_ERR();
+
+ /* create our necessary data objects to verify the signature */
+ file = fopen(path, "rb");
+ if(file == NULL) {
+ handle->pm_errno = ALPM_ERR_NOT_A_FILE;
+ goto error;
+ }
+ err = gpgme_data_new_from_stream(&filedata, file);
+ CHECK_ERR();
+
+ /* next create data object for the signature */
+ if(base64_sig) {
+ /* memory-based, we loaded it from a sync DB */
+ int data_len;
+ int decode_ret = decode_signature(base64_sig,
+ &decoded_sigdata, &data_len);
+ if(decode_ret) {
+ handle->pm_errno = ALPM_ERR_SIG_INVALID;
+ goto error;
+ }
+ err = gpgme_data_new_from_mem(&sigdata,
+ (char *)decoded_sigdata, data_len, 0);
+ } else {
+ /* file-based, it is on disk */
+ sigfile = fopen(sigpath, "rb");
+ if(sigfile == NULL) {
+ handle->pm_errno = ALPM_ERR_SIG_MISSING;
+ goto error;
+ }
+ err = gpgme_data_new_from_stream(&sigdata, sigfile);
+ }
+ CHECK_ERR();
+
+ /* here's where the magic happens */
+ err = gpgme_op_verify(ctx, sigdata, filedata, NULL);
+ CHECK_ERR();
+ verify_result = gpgme_op_verify_result(ctx);
+ CHECK_ERR();
+ if(!verify_result || !verify_result->signatures) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "no signatures returned\n");
+ handle->pm_errno = ALPM_ERR_SIG_MISSING;
+ goto error;
+ }
+ for(gpgsig = verify_result->signatures, sigcount = 0;
+ gpgsig; gpgsig = gpgsig->next, sigcount++);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "%d signatures returned\n", sigcount);
+
+ result->status = calloc(sigcount, sizeof(alpm_sigstatus_t));
+ result->validity = calloc(sigcount, sizeof(alpm_sigvalidity_t));
+ result->uid = calloc(sigcount, sizeof(char*));
+ if(!result->status || !result->validity || !result->uid) {
+ handle->pm_errno = ALPM_ERR_MEMORY;
+ goto error;
+ }
+ result->count = sigcount;
+
+ for(gpgsig = verify_result->signatures, sigcount = 0; gpgsig;
+ gpgsig = gpgsig->next, sigcount++) {
+ alpm_list_t *summary_list, *summary;
+ alpm_sigstatus_t status;
+ alpm_sigvalidity_t validity;
+ gpgme_key_t key;
+
+ _alpm_log(handle, ALPM_LOG_DEBUG, "fingerprint: %s\n", gpgsig->fpr);
+ summary_list = list_sigsum(gpgsig->summary);
+ for(summary = summary_list; summary; summary = summary->next) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "summary: %s\n", (const char *)summary->data);
+ }
+ alpm_list_free(summary_list);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "status: %s\n", gpgme_strerror(gpgsig->status));
+ _alpm_log(handle, ALPM_LOG_DEBUG, "timestamp: %lu\n", gpgsig->timestamp);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "exp_timestamp: %lu\n", gpgsig->exp_timestamp);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "validity: %s; reason: %s\n",
+ string_validity(gpgsig->validity),
+ gpgme_strerror(gpgsig->validity_reason));
+
+ err = gpgme_get_key(ctx, gpgsig->fpr, &key, 0);
+ if(gpg_err_code(err) == GPG_ERR_EOF) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "key lookup failed, unknown key\n");
+ err = GPG_ERR_NO_ERROR;
+ STRDUP(result->uid[sigcount], gpgsig->fpr,
+ handle->pm_errno = ALPM_ERR_MEMORY; goto error);
+ } else {
+ CHECK_ERR();
+ if(key->uids) {
+ const char *uid = key->uids->uid;
+ STRDUP(result->uid[sigcount], uid,
+ handle->pm_errno = ALPM_ERR_MEMORY; goto error);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "key user: %s\n", uid);
+ }
+ gpgme_key_unref(key);
+ }
+
+ switch(gpg_err_code(gpgsig->status)) {
+ /* good cases */
+ case GPG_ERR_NO_ERROR:
+ status = ALPM_SIGSTATUS_VALID;
+ break;
+ case GPG_ERR_KEY_EXPIRED:
+ status = ALPM_SIGSTATUS_KEY_EXPIRED;
+ break;
+ /* bad cases */
+ case GPG_ERR_SIG_EXPIRED:
+ status = ALPM_SIGSTATUS_SIG_EXPIRED;
+ break;
+ case GPG_ERR_NO_PUBKEY:
+ status = ALPM_SIGSTATUS_KEY_UNKNOWN;
+ break;
+ case GPG_ERR_BAD_SIGNATURE:
+ default:
+ status = ALPM_SIGSTATUS_INVALID;
+ break;
+ }
+
+ if(status == ALPM_SIGSTATUS_VALID
+ || status == ALPM_SIGSTATUS_KEY_EXPIRED) {
+ switch(gpgsig->validity) {
+ case GPGME_VALIDITY_ULTIMATE:
+ case GPGME_VALIDITY_FULL:
+ validity = ALPM_SIGVALIDITY_FULL;
+ break;
+ case GPGME_VALIDITY_MARGINAL:
+ validity = ALPM_SIGVALIDITY_MARGINAL;
+ break;
+ case GPGME_VALIDITY_NEVER:
+ validity = ALPM_SIGVALIDITY_NEVER;
+ break;
+ case GPGME_VALIDITY_UNKNOWN:
+ case GPGME_VALIDITY_UNDEFINED:
+ default:
+ validity = ALPM_SIGVALIDITY_UNKNOWN;
+ break;
+ }
+ } else {
+ validity = ALPM_SIGVALIDITY_NEVER;
+ }
+
+ result->status[sigcount] = status;
+ result->validity[sigcount] = validity;
+ }
+
+ ret = 0;
+
+error:
+ gpgme_data_release(sigdata);
+ gpgme_data_release(filedata);
+ gpgme_release(ctx);
+ if(sigfile) {
+ fclose(sigfile);
+ }
+ if(file) {
+ fclose(file);
+ }
+ FREE(sigpath);
+ FREE(decoded_sigdata);
+ if(gpg_err_code(err) != GPG_ERR_NO_ERROR) {
+ _alpm_log(handle, ALPM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(err));
+ RET_ERR(handle, ALPM_ERR_GPGME, -1);
+ }
+ return ret;
+}
+#else
+int _alpm_gpgme_checksig(alpm_handle_t UNUSED *handle, const char UNUSED *path,
+ const char UNUSED *base64_sig, alpm_sigresult_t UNUSED *result)
+{
+ return -1;
+}
+#endif
+
+int _alpm_check_pgp_helper(alpm_handle_t *handle, const char *path,
+ const char *base64_sig, int optional, int marginal, int unknown,
+ enum _alpm_errno_t invalid_err)
+{
+ alpm_sigresult_t result;
+ int ret;
+
+ memset(&result, 0, sizeof(result));
+
+ _alpm_log(handle, ALPM_LOG_DEBUG, "checking signatures for %s\n", path);
+ ret = _alpm_gpgme_checksig(handle, path, base64_sig, &result);
+ if(ret && handle->pm_errno == ALPM_ERR_SIG_MISSING) {
+ if(optional) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "missing optional signature\n");
+ handle->pm_errno = 0;
+ ret = 0;
+ } else {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "missing required signature\n");
+ /* ret will already be -1 */
+ }
+ } else if(ret) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "signature check failed\n");
+ /* ret will already be -1 */
+ } else {
+ int num;
+ for(num = 0; !ret && num < result.count; num++) {
+ switch(result.status[num]) {
+ case ALPM_SIGSTATUS_VALID:
+ case ALPM_SIGSTATUS_KEY_EXPIRED:
+ _alpm_log(handle, ALPM_LOG_DEBUG, "signature is valid\n");
+ switch(result.validity[num]) {
+ case ALPM_SIGVALIDITY_FULL:
+ _alpm_log(handle, ALPM_LOG_DEBUG, "signature is fully trusted\n");
+ break;
+ case ALPM_SIGVALIDITY_MARGINAL:
+ _alpm_log(handle, ALPM_LOG_DEBUG, "signature is marginal trust\n");
+ if(!marginal) {
+ ret = -1;
+ }
+ break;
+ case ALPM_SIGVALIDITY_UNKNOWN:
+ _alpm_log(handle, ALPM_LOG_DEBUG, "signature is unknown trust\n");
+ if(!unknown) {
+ ret = -1;
+ }
+ break;
+ case ALPM_SIGVALIDITY_NEVER:
+ _alpm_log(handle, ALPM_LOG_DEBUG, "signature should never be trusted\n");
+ ret = -1;
+ break;
+ }
+ break;
+ case ALPM_SIGSTATUS_SIG_EXPIRED:
+ case ALPM_SIGSTATUS_KEY_UNKNOWN:
+ case ALPM_SIGSTATUS_INVALID:
+ _alpm_log(handle, ALPM_LOG_DEBUG, "signature is not valid\n");
+ ret = -1;
+ break;
+ }
+ }
+
+ if(ret) {
+ handle->pm_errno = invalid_err;
+ }
+ }
+
+ alpm_sigresult_cleanup(&result);
+ return ret;
+}
+
+/**
+ * Check the PGP signature for the given package file.
+ * @param pkg the package to check
+ * @return a int value : 0 (valid), 1 (invalid), -1 (an error occurred)
+ */
+int SYMEXPORT alpm_pkg_check_pgp_signature(alpm_pkg_t *pkg,
+ alpm_sigresult_t *result)
+{
+ ASSERT(pkg != NULL, return -1);
+ ASSERT(result != NULL, RET_ERR(pkg->handle, ALPM_ERR_WRONG_ARGS, -1));
+ pkg->handle->pm_errno = 0;
+
+ return _alpm_gpgme_checksig(pkg->handle, alpm_pkg_get_filename(pkg),
+ pkg->base64_sig, result);
+}
+
+/**
+ * Check the PGP signature for the given database.
+ * @param db the database to check
+ * @return a int value : 0 (valid), 1 (invalid), -1 (an error occurred)
+ */
+int SYMEXPORT alpm_db_check_pgp_signature(alpm_db_t *db,
+ alpm_sigresult_t *result)
+{
+ ASSERT(db != NULL, return -1);
+ ASSERT(result != NULL, RET_ERR(db->handle, ALPM_ERR_WRONG_ARGS, -1));
+ db->handle->pm_errno = 0;
+
+ return _alpm_gpgme_checksig(db->handle, _alpm_db_path(db), NULL, result);
+}
+
+int SYMEXPORT alpm_sigresult_cleanup(alpm_sigresult_t *result)
+{
+ ASSERT(result != NULL, return -1);
+ /* Because it is likely result is on the stack, uid and status may have bogus
+ * values in the struct. Only look at them if count is greater than 0. */
+ if(result->count > 0) {
+ free(result->status);
+ if(result->uid) {
+ int i;
+ for(i = 0; i < result->count; i++) {
+ free(result->uid[i]);
+ }
+ free(result->uid);
+ }
+ }
+ return 0;
+}
+
+/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/signing.h b/lib/libalpm/signing.h
new file mode 100644
index 00000000..22f6357e
--- /dev/null
+++ b/lib/libalpm/signing.h
@@ -0,0 +1,32 @@
+/*
+ * signing.h
+ *
+ * Copyright (c) 2008-2011 Pacman Development Team <pacman-dev@archlinux.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/>.
+ */
+#ifndef _ALPM_SIGNING_H
+#define _ALPM_SIGNING_H
+
+#include "alpm.h"
+
+int _alpm_gpgme_checksig(alpm_handle_t *handle, const char *path,
+ const char *base64_sig, alpm_sigresult_t *result);
+int _alpm_check_pgp_helper(alpm_handle_t *handle, const char *path,
+ const char *base64_sig, int optional, int marginal, int unknown,
+ enum _alpm_errno_t invalid_err);
+
+#endif /* _ALPM_SIGNING_H */
+
+/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/sync.c b/lib/libalpm/sync.c
index f83b0ef9..ca7e6579 100644
--- a/lib/libalpm/sync.c
+++ b/lib/libalpm/sync.c
@@ -26,11 +26,9 @@
#include <sys/types.h> /* off_t */
#include <stdlib.h>
#include <stdio.h>
-#include <fcntl.h>
#include <string.h>
#include <stdint.h> /* intmax_t */
#include <unistd.h>
-#include <time.h>
#include <limits.h>
/* libalpm */
@@ -50,144 +48,149 @@
#include "delta.h"
#include "remove.h"
#include "diskspace.h"
+#include "signing.h"
/** Check for new version of pkg in sync repos
* (only the first occurrence is considered in sync)
*/
-pmpkg_t SYMEXPORT *alpm_sync_newversion(pmpkg_t *pkg, alpm_list_t *dbs_sync)
+alpm_pkg_t SYMEXPORT *alpm_sync_newversion(alpm_pkg_t *pkg, alpm_list_t *dbs_sync)
{
- ASSERT(pkg != NULL, return(NULL));
-
alpm_list_t *i;
- pmpkg_t *spkg = NULL;
+ alpm_pkg_t *spkg = NULL;
+
+ ASSERT(pkg != NULL, return NULL);
+ pkg->handle->pm_errno = 0;
for(i = dbs_sync; !spkg && i; i = i->next) {
spkg = _alpm_db_get_pkgfromcache(i->data, alpm_pkg_get_name(pkg));
}
if(spkg == NULL) {
- _alpm_log(PM_LOG_DEBUG, "'%s' not found in sync db => no upgrade\n",
+ _alpm_log(pkg->handle, ALPM_LOG_DEBUG, "'%s' not found in sync db => no upgrade\n",
alpm_pkg_get_name(pkg));
- return(NULL);
+ return NULL;
}
/* compare versions and see if spkg is an upgrade */
if(_alpm_pkg_compare_versions(spkg, pkg) > 0) {
- _alpm_log(PM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
+ _alpm_log(pkg->handle, ALPM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg),
alpm_pkg_get_version(spkg));
- return(spkg);
+ return spkg;
}
/* spkg is not an upgrade */
- return(NULL);
+ return NULL;
}
-/** Search for packages to upgrade and add them to the transaction.
- * @return 0 on success, -1 on error (pm_errno is set accordingly)
- */
-int SYMEXPORT alpm_sync_sysupgrade(int enable_downgrade)
+/** Search for packages to upgrade and add them to the transaction. */
+int SYMEXPORT alpm_sync_sysupgrade(alpm_handle_t *handle, int enable_downgrade)
{
alpm_list_t *i, *j, *k;
- pmtrans_t *trans;
- pmdb_t *db_local;
+ alpm_trans_t *trans;
+ alpm_db_t *db_local;
alpm_list_t *dbs_sync;
- ALPM_LOG_FUNC;
-
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
trans = handle->trans;
db_local = handle->db_local;
dbs_sync = handle->dbs_sync;
- 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 != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
+ ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1));
- _alpm_log(PM_LOG_DEBUG, "checking for package upgrades\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "checking for package upgrades\n");
for(i = _alpm_db_get_pkgcache(db_local); i; i = i->next) {
- pmpkg_t *lpkg = i->data;
+ alpm_pkg_t *lpkg = i->data;
if(_alpm_pkg_find(trans->add, lpkg->name)) {
- _alpm_log(PM_LOG_DEBUG, "%s is already in the target list -- skipping\n", lpkg->name);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "%s is already in the target list -- skipping\n", lpkg->name);
continue;
}
/* Search for literal then replacers in each sync database.
* If found, don't check other databases */
for(j = dbs_sync; j; j = j->next) {
- pmdb_t *sdb = j->data;
+ alpm_db_t *sdb = j->data;
/* Check sdb */
- pmpkg_t *spkg = _alpm_db_get_pkgfromcache(sdb, lpkg->name);
- if(spkg) { /* 1. literal was found in sdb */
+ alpm_pkg_t *spkg = _alpm_db_get_pkgfromcache(sdb, lpkg->name);
+ if(spkg) {
+ /* 1. literal was found in sdb */
int cmp = _alpm_pkg_compare_versions(spkg, lpkg);
if(cmp > 0) {
- _alpm_log(PM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
lpkg->name, lpkg->version, spkg->version);
/* check IgnorePkg/IgnoreGroup */
- if(_alpm_pkg_should_ignore(spkg) || _alpm_pkg_should_ignore(lpkg)) {
- _alpm_log(PM_LOG_WARNING, _("%s: ignoring package upgrade (%s => %s)\n"),
- lpkg->name, lpkg->version, spkg->version);
+ if(_alpm_pkg_should_ignore(handle, spkg)
+ || _alpm_pkg_should_ignore(handle, lpkg)) {
+ _alpm_log(handle, ALPM_LOG_WARNING, _("%s: ignoring package upgrade (%s => %s)\n"),
+ lpkg->name, lpkg->version, spkg->version);
} else {
- _alpm_log(PM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
spkg->name, spkg->version);
trans->add = alpm_list_add(trans->add, spkg);
}
} else if(cmp < 0) {
if(enable_downgrade) {
/* check IgnorePkg/IgnoreGroup */
- if(_alpm_pkg_should_ignore(spkg) || _alpm_pkg_should_ignore(lpkg)) {
- _alpm_log(PM_LOG_WARNING, _("%s: ignoring package downgrade (%s => %s)\n"),
+ if(_alpm_pkg_should_ignore(handle, spkg)
+ || _alpm_pkg_should_ignore(handle, lpkg)) {
+ _alpm_log(handle, ALPM_LOG_WARNING, _("%s: ignoring package downgrade (%s => %s)\n"),
lpkg->name, lpkg->version, spkg->version);
} else {
- _alpm_log(PM_LOG_WARNING, _("%s: downgrading from version %s to version %s\n"),
+ _alpm_log(handle, ALPM_LOG_WARNING, _("%s: downgrading from version %s to version %s\n"),
lpkg->name, lpkg->version, spkg->version);
trans->add = alpm_list_add(trans->add, spkg);
}
} else {
- _alpm_log(PM_LOG_WARNING, _("%s: local (%s) is newer than %s (%s)\n"),
+ _alpm_log(handle, ALPM_LOG_WARNING, _("%s: local (%s) is newer than %s (%s)\n"),
lpkg->name, lpkg->version, sdb->treename, spkg->version);
}
}
- break; /* jump to next local package */
- } else { /* 2. search for replacers in sdb */
+ /* jump to next local package */
+ break;
+ } else {
+ /* 2. search for replacers in sdb */
int found = 0;
for(k = _alpm_db_get_pkgcache(sdb); k; k = k->next) {
spkg = k->data;
if(alpm_list_find_str(alpm_pkg_get_replaces(spkg), lpkg->name)) {
found = 1;
/* check IgnorePkg/IgnoreGroup */
- if(_alpm_pkg_should_ignore(spkg) || _alpm_pkg_should_ignore(lpkg)) {
- _alpm_log(PM_LOG_WARNING, _("ignoring package replacement (%s-%s => %s-%s)\n"),
+ if(_alpm_pkg_should_ignore(handle, spkg)
+ || _alpm_pkg_should_ignore(handle, lpkg)) {
+ _alpm_log(handle, ALPM_LOG_WARNING, _("ignoring package replacement (%s-%s => %s-%s)\n"),
lpkg->name, lpkg->version, spkg->name, spkg->version);
continue;
}
int doreplace = 0;
- QUESTION(trans, PM_TRANS_CONV_REPLACE_PKG, lpkg, spkg, sdb->treename, &doreplace);
+ QUESTION(trans, ALPM_TRANS_CONV_REPLACE_PKG, lpkg, spkg, sdb->treename, &doreplace);
if(!doreplace) {
continue;
}
/* If spkg is already in the target list, we append lpkg to spkg's
* removes list */
- pmpkg_t *tpkg = _alpm_pkg_find(trans->add, spkg->name);
+ alpm_pkg_t *tpkg = _alpm_pkg_find(trans->add, spkg->name);
if(tpkg) {
/* sanity check, multiple repos can contain spkg->name */
if(tpkg->origin_data.db != sdb) {
- _alpm_log(PM_LOG_WARNING, _("cannot replace %s by %s\n"),
+ _alpm_log(handle, ALPM_LOG_WARNING, _("cannot replace %s by %s\n"),
lpkg->name, spkg->name);
continue;
}
- _alpm_log(PM_LOG_DEBUG, "appending %s to the removes list of %s\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "appending %s to the removes list of %s\n",
lpkg->name, tpkg->name);
tpkg->removes = alpm_list_add(tpkg->removes, lpkg);
/* check the to-be-replaced package's reason field */
- if(alpm_pkg_get_reason(lpkg) == PM_PKG_REASON_EXPLICIT) {
- tpkg->reason = PM_PKG_REASON_EXPLICIT;
+ if(alpm_pkg_get_reason(lpkg) == ALPM_PKG_REASON_EXPLICIT) {
+ tpkg->reason = ALPM_PKG_REASON_EXPLICIT;
}
- } else { /* add spkg to the target list */
+ } else {
+ /* add spkg to the target list */
/* copy over reason */
spkg->reason = alpm_pkg_get_reason(lpkg);
spkg->removes = alpm_list_add(NULL, lpkg);
- _alpm_log(PM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
spkg->name, spkg->version);
trans->add = alpm_list_add(trans->add, spkg);
}
@@ -200,38 +203,38 @@ int SYMEXPORT alpm_sync_sysupgrade(int enable_downgrade)
}
}
- return(0);
+ return 0;
}
/** Find group members across a list of databases.
* If a member exists in several databases, only the first database is used.
* IgnorePkg is also handled.
- * @param dbs the list of pmdb_t *
+ * @param dbs the list of alpm_db_t *
* @pram name the name of the group
- * @return the list of pmpkg_t * (caller is responsible for alpm_list_free)
+ * @return the list of alpm_pkg_t * (caller is responsible for alpm_list_free)
*/
-alpm_list_t SYMEXPORT *alpm_find_grp_pkgs(alpm_list_t *dbs,
+alpm_list_t SYMEXPORT *alpm_find_group_pkgs(alpm_list_t *dbs,
const char *name)
{
alpm_list_t *i, *j, *pkgs = NULL, *ignorelist = NULL;
for(i = dbs; i; i = i->next) {
- pmdb_t *db = i->data;
- pmgrp_t *grp = alpm_db_readgrp(db, name);
+ alpm_db_t *db = i->data;
+ alpm_group_t *grp = alpm_db_readgroup(db, name);
if(!grp)
continue;
- for(j = alpm_grp_get_pkgs(grp); j; j = j->next) {
- pmpkg_t *pkg = j->data;
+ for(j = grp->packages; j; j = j->next) {
+ alpm_pkg_t *pkg = j->data;
if(_alpm_pkg_find(ignorelist, alpm_pkg_get_name(pkg))) {
continue;
}
- if(_alpm_pkg_should_ignore(pkg)) {
+ if(_alpm_pkg_should_ignore(db->handle, pkg)) {
ignorelist = alpm_list_add(ignorelist, pkg);
int install = 0;
- QUESTION(handle->trans, PM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
+ QUESTION(db->handle->trans, ALPM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
NULL, NULL, &install);
if(!install)
continue;
@@ -242,28 +245,29 @@ alpm_list_t SYMEXPORT *alpm_find_grp_pkgs(alpm_list_t *dbs,
}
}
alpm_list_free(ignorelist);
- return(pkgs);
+ return pkgs;
}
/** Compute the size of the files that will be downloaded to install a
* package.
* @param newpkg the new package to upgrade to
*/
-static int compute_download_size(pmpkg_t *newpkg)
+static int compute_download_size(alpm_pkg_t *newpkg)
{
const char *fname;
char *fpath;
off_t size = 0;
+ alpm_handle_t *handle = newpkg->handle;
if(newpkg->origin != PKG_FROM_SYNCDB) {
newpkg->infolevel |= INFRQ_DSIZE;
newpkg->download_size = 0;
- return(0);
+ return 0;
}
fname = alpm_pkg_get_filename(newpkg);
- ASSERT(fname != NULL, RET_ERR(PM_ERR_PKG_INVALID_NAME, -1));
- fpath = _alpm_filecache_find(fname);
+ ASSERT(fname != NULL, RET_ERR(handle, ALPM_ERR_PKG_INVALID_NAME, -1));
+ fpath = _alpm_filecache_find(handle, fname);
if(fpath) {
FREE(fpath);
@@ -272,16 +276,16 @@ static int compute_download_size(pmpkg_t *newpkg)
off_t dltsize;
off_t pkgsize = alpm_pkg_get_size(newpkg);
- dltsize = _alpm_shortest_delta_path(
+ dltsize = _alpm_shortest_delta_path(handle,
alpm_pkg_get_deltas(newpkg),
alpm_pkg_get_filename(newpkg),
&newpkg->delta_path);
if(newpkg->delta_path && (dltsize < pkgsize * MAX_DELTA_RATIO)) {
- _alpm_log(PM_LOG_DEBUG, "using delta size\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "using delta size\n");
size = dltsize;
} else {
- _alpm_log(PM_LOG_DEBUG, "using package size\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "using package size\n");
size = alpm_pkg_get_size(newpkg);
alpm_list_free(newpkg->delta_path);
newpkg->delta_path = NULL;
@@ -290,42 +294,46 @@ static int compute_download_size(pmpkg_t *newpkg)
size = alpm_pkg_get_size(newpkg);
}
- _alpm_log(PM_LOG_DEBUG, "setting download size %jd for pkg %s\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "setting download size %jd for pkg %s\n",
(intmax_t)size, alpm_pkg_get_name(newpkg));
newpkg->infolevel |= INFRQ_DSIZE;
newpkg->download_size = size;
- return(0);
+ return 0;
}
-int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync, alpm_list_t **data)
+int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
{
+ alpm_list_t *i, *j;
alpm_list_t *deps = NULL;
alpm_list_t *unresolvable = NULL;
- alpm_list_t *i, *j;
alpm_list_t *remove = NULL;
int ret = 0;
-
- ALPM_LOG_FUNC;
-
- ASSERT(db_local != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
+ alpm_trans_t *trans = handle->trans;
if(data) {
*data = NULL;
}
- if(!(trans->flags & PM_TRANS_FLAG_NODEPS)) {
+ /* ensure all sync database are valid since we will be using them */
+ for(i = handle->dbs_sync; i; i = i->next) {
+ const alpm_db_t *db = i->data;
+ if(!(db->status & DB_STATUS_VALID)) {
+ RET_ERR(handle, ALPM_ERR_DB_INVALID, -1);
+ }
+ }
+
+ if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) {
alpm_list_t *resolved = NULL; /* target list after resolvedeps */
/* Build up list by repeatedly resolving each transaction package */
/* Resolve targets dependencies */
- EVENT(trans, PM_TRANS_EVT_RESOLVEDEPS_START, NULL, NULL);
- _alpm_log(PM_LOG_DEBUG, "resolving target's dependencies\n");
+ EVENT(trans, ALPM_TRANS_EVT_RESOLVEDEPS_START, NULL, NULL);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "resolving target's dependencies\n");
/* build remove list for resolvedeps */
for(i = trans->add; i; i = i->next) {
- pmpkg_t *spkg = i->data;
+ alpm_pkg_t *spkg = i->data;
for(j = spkg->removes; j; j = j->next) {
remove = alpm_list_add(remove, j->data);
}
@@ -333,14 +341,14 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
/* Compute the fake local database for resolvedeps (partial fix for the
* phonon/qt issue) */
- alpm_list_t *localpkgs = alpm_list_diff(_alpm_db_get_pkgcache(db_local),
+ alpm_list_t *localpkgs = alpm_list_diff(_alpm_db_get_pkgcache(handle->db_local),
trans->add, _alpm_pkg_cmp);
/* Resolve packages in the transaction one at a time, in addition
building up a list of packages which could not be resolved. */
for(i = trans->add; i; i = i->next) {
- pmpkg_t *pkg = i->data;
- if(_alpm_resolvedeps(localpkgs, dbs_sync, pkg, trans->add,
+ alpm_pkg_t *pkg = i->data;
+ if(_alpm_resolvedeps(handle, localpkgs, pkg, trans->add,
&resolved, remove, data) == -1) {
unresolvable = alpm_list_add(unresolvable, pkg);
}
@@ -353,14 +361,14 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
see if they'd like to ignore them rather than failing the sync */
if(unresolvable != NULL) {
int remove_unresolvable = 0;
- QUESTION(handle->trans, PM_TRANS_CONV_REMOVE_PKGS, unresolvable,
+ QUESTION(trans, ALPM_TRANS_CONV_REMOVE_PKGS, unresolvable,
NULL, NULL, &remove_unresolvable);
- if (remove_unresolvable) {
+ if(remove_unresolvable) {
/* User wants to remove the unresolvable packages from the
transaction. The packages will be removed from the actual
transaction when the transaction packages are replaced with a
dependency-reordered list below */
- pm_errno = 0; /* pm_errno was set by resolvedeps */
+ handle->pm_errno = 0; /* pm_errno was set by resolvedeps */
if(data) {
alpm_list_free_inner(*data, (alpm_list_fn_free)_alpm_depmiss_free);
alpm_list_free(*data);
@@ -376,9 +384,9 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
/* Set DEPEND reason for pulled packages */
for(i = resolved; i; i = i->next) {
- pmpkg_t *pkg = i->data;
+ alpm_pkg_t *pkg = i->data;
if(!_alpm_pkg_find(trans->add, pkg->name)) {
- pkg->reason = PM_PKG_REASON_DEPEND;
+ pkg->reason = ALPM_PKG_REASON_DEPEND;
}
}
@@ -388,25 +396,25 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
/* re-order w.r.t. dependencies */
alpm_list_free(trans->add);
- trans->add = _alpm_sortbydeps(resolved, 0);
+ trans->add = _alpm_sortbydeps(handle, resolved, 0);
alpm_list_free(resolved);
- EVENT(trans, PM_TRANS_EVT_RESOLVEDEPS_DONE, NULL, NULL);
+ EVENT(trans, ALPM_TRANS_EVT_RESOLVEDEPS_DONE, NULL, NULL);
}
- if(!(trans->flags & PM_TRANS_FLAG_NOCONFLICTS)) {
+ if(!(trans->flags & ALPM_TRANS_FLAG_NOCONFLICTS)) {
/* check for inter-conflicts and whatnot */
- EVENT(trans, PM_TRANS_EVT_INTERCONFLICTS_START, NULL, NULL);
+ EVENT(trans, ALPM_TRANS_EVT_INTERCONFLICTS_START, NULL, NULL);
- _alpm_log(PM_LOG_DEBUG, "looking for conflicts\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "looking for conflicts\n");
/* 1. check for conflicts in the target list */
- _alpm_log(PM_LOG_DEBUG, "check targets vs targets\n");
- deps = _alpm_innerconflicts(trans->add);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "check targets vs targets\n");
+ deps = _alpm_innerconflicts(handle, trans->add);
for(i = deps; i; i = i->next) {
- pmconflict_t *conflict = i->data;
- pmpkg_t *rsync, *sync, *sync1, *sync2;
+ alpm_conflict_t *conflict = i->data;
+ alpm_pkg_t *rsync, *sync, *sync1, *sync2;
/* have we already removed one of the conflicting targets? */
sync1 = _alpm_pkg_find(trans->add, conflict->package1);
@@ -415,12 +423,12 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
continue;
}
- _alpm_log(PM_LOG_DEBUG, "conflicting packages in the sync list: '%s' <-> '%s'\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "conflicting packages in the sync list: '%s' <-> '%s'\n",
conflict->package1, conflict->package2);
/* if sync1 provides sync2, we remove sync2 from the targets, and vice versa */
- pmdepend_t *dep1 = _alpm_splitdep(conflict->package1);
- pmdepend_t *dep2 = _alpm_splitdep(conflict->package2);
+ alpm_depend_t *dep1 = _alpm_splitdep(conflict->package1);
+ alpm_depend_t *dep2 = _alpm_splitdep(conflict->package2);
if(_alpm_depcmp(sync1, dep2)) {
rsync = sync2;
sync = sync1;
@@ -428,11 +436,11 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
rsync = sync1;
sync = sync2;
} else {
- _alpm_log(PM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
- pm_errno = PM_ERR_CONFLICTING_DEPS;
+ _alpm_log(handle, ALPM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
+ handle->pm_errno = ALPM_ERR_CONFLICTING_DEPS;
ret = -1;
if(data) {
- pmconflict_t *newconflict = _alpm_conflict_dup(conflict);
+ alpm_conflict_t *newconflict = _alpm_conflict_dup(conflict);
if(newconflict) {
*data = alpm_list_add(*data, newconflict);
}
@@ -447,7 +455,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
_alpm_dep_free(dep2);
/* Prints warning */
- _alpm_log(PM_LOG_WARNING,
+ _alpm_log(handle, ALPM_LOG_WARNING,
_("removing '%s' from target list because it conflicts with '%s'\n"),
rsync->name, sync->name);
trans->add = alpm_list_remove(trans->add, rsync, _alpm_pkg_cmp, NULL);
@@ -460,17 +468,17 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
deps = NULL;
/* 2. we check for target vs db conflicts (and resolve)*/
- _alpm_log(PM_LOG_DEBUG, "check targets vs db and db vs targets\n");
- deps = _alpm_outerconflicts(db_local, trans->add);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "check targets vs db and db vs targets\n");
+ deps = _alpm_outerconflicts(handle->db_local, trans->add);
for(i = deps; i; i = i->next) {
- pmconflict_t *conflict = i->data;
+ alpm_conflict_t *conflict = i->data;
/* if conflict->package2 (the local package) is not elected for removal,
we ask the user */
int found = 0;
for(j = trans->add; j && !found; j = j->next) {
- pmpkg_t *spkg = j->data;
+ alpm_pkg_t *spkg = j->data;
if(_alpm_pkg_find(spkg->removes, conflict->package2)) {
found = 1;
}
@@ -479,24 +487,24 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
continue;
}
- _alpm_log(PM_LOG_DEBUG, "package '%s' conflicts with '%s'\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "package '%s' conflicts with '%s'\n",
conflict->package1, conflict->package2);
- pmpkg_t *sync = _alpm_pkg_find(trans->add, conflict->package1);
- pmpkg_t *local = _alpm_db_get_pkgfromcache(db_local, conflict->package2);
+ alpm_pkg_t *sync = _alpm_pkg_find(trans->add, conflict->package1);
+ alpm_pkg_t *local = _alpm_db_get_pkgfromcache(handle->db_local, conflict->package2);
int doremove = 0;
- QUESTION(trans, PM_TRANS_CONV_CONFLICT_PKG, conflict->package1,
+ QUESTION(trans, ALPM_TRANS_CONV_CONFLICT_PKG, conflict->package1,
conflict->package2, conflict->reason, &doremove);
if(doremove) {
/* append to the removes list */
- _alpm_log(PM_LOG_DEBUG, "electing '%s' for removal\n", conflict->package2);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "electing '%s' for removal\n", conflict->package2);
sync->removes = alpm_list_add(sync->removes, local);
} else { /* abort */
- _alpm_log(PM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
- pm_errno = PM_ERR_CONFLICTING_DEPS;
+ _alpm_log(handle, ALPM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
+ handle->pm_errno = ALPM_ERR_CONFLICTING_DEPS;
ret = -1;
if(data) {
- pmconflict_t *newconflict = _alpm_conflict_dup(conflict);
+ alpm_conflict_t *newconflict = _alpm_conflict_dup(conflict);
if(newconflict) {
*data = alpm_list_add(*data, newconflict);
}
@@ -506,28 +514,29 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
goto cleanup;
}
}
- EVENT(trans, PM_TRANS_EVT_INTERCONFLICTS_DONE, NULL, NULL);
+ EVENT(trans, ALPM_TRANS_EVT_INTERCONFLICTS_DONE, NULL, NULL);
alpm_list_free_inner(deps, (alpm_list_fn_free)_alpm_conflict_free);
alpm_list_free(deps);
}
/* Build trans->remove list */
for(i = trans->add; i; i = i->next) {
- pmpkg_t *spkg = i->data;
+ alpm_pkg_t *spkg = i->data;
for(j = spkg->removes; j; j = j->next) {
- pmpkg_t *rpkg = j->data;
+ alpm_pkg_t *rpkg = j->data;
if(!_alpm_pkg_find(trans->remove, rpkg->name)) {
- _alpm_log(PM_LOG_DEBUG, "adding '%s' to remove list\n", rpkg->name);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "adding '%s' to remove list\n", rpkg->name);
trans->remove = alpm_list_add(trans->remove, _alpm_pkg_dup(rpkg));
}
}
}
- if(!(trans->flags & PM_TRANS_FLAG_NODEPS)) {
- _alpm_log(PM_LOG_DEBUG, "checking dependencies\n");
- deps = alpm_checkdeps(_alpm_db_get_pkgcache(db_local), 1, trans->remove, trans->add);
+ if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "checking dependencies\n");
+ deps = alpm_checkdeps(handle, _alpm_db_get_pkgcache(handle->db_local),
+ trans->remove, trans->add, 1);
if(deps) {
- pm_errno = PM_ERR_UNSATISFIED_DEPS;
+ handle->pm_errno = ALPM_ERR_UNSATISFIED_DEPS;
ret = -1;
if(data) {
*data = deps;
@@ -540,7 +549,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
}
for(i = trans->add; i; i = i->next) {
/* update download size field */
- pmpkg_t *spkg = i->data;
+ alpm_pkg_t *spkg = i->data;
if(compute_download_size(spkg) != 0) {
ret = -1;
goto cleanup;
@@ -551,7 +560,7 @@ cleanup:
alpm_list_free(unresolvable);
alpm_list_free(remove);
- return(ret);
+ return ret;
}
/** Returns the size of the files that will be downloaded to install a
@@ -559,18 +568,18 @@ cleanup:
* @param newpkg the new package to upgrade to
* @return the size of the download
*/
-off_t SYMEXPORT alpm_pkg_download_size(pmpkg_t *newpkg)
+off_t SYMEXPORT alpm_pkg_download_size(alpm_pkg_t *newpkg)
{
if(!(newpkg->infolevel & INFRQ_DSIZE)) {
compute_download_size(newpkg);
}
- return(newpkg->download_size);
+ return newpkg->download_size;
}
static int endswith(const char *filename, const char *extension)
{
const char *s = filename + strlen(filename) - strlen(extension);
- return(strcmp(s, extension) == 0);
+ return strcmp(s, extension) == 0;
}
/** Applies delta files to create an upgraded package file.
@@ -578,18 +587,19 @@ static int endswith(const char *filename, const char *extension)
* All intermediate files are deleted, leaving only the starting and
* ending package files.
*
- * @param trans the transaction
+ * @param handle the context handle
*
* @return 0 if all delta files were able to be applied, 1 otherwise.
*/
-static int apply_deltas(pmtrans_t *trans)
+static int apply_deltas(alpm_handle_t *handle)
{
alpm_list_t *i;
int ret = 0;
- const char *cachedir = _alpm_filecache_setup();
+ const char *cachedir = _alpm_filecache_setup(handle);
+ alpm_trans_t *trans = handle->trans;
for(i = trans->add; i; i = i->next) {
- pmpkg_t *spkg = i->data;
+ alpm_pkg_t *spkg = i->data;
alpm_list_t *delta_path = spkg->delta_path;
alpm_list_t *dlts = NULL;
@@ -598,23 +608,23 @@ static int apply_deltas(pmtrans_t *trans)
}
for(dlts = delta_path; dlts; dlts = dlts->next) {
- pmdelta_t *d = dlts->data;
+ alpm_delta_t *d = dlts->data;
char *delta, *from, *to;
char command[PATH_MAX];
size_t len = 0;
- delta = _alpm_filecache_find(d->delta);
+ delta = _alpm_filecache_find(handle, d->delta);
/* the initial package might be in a different cachedir */
if(dlts == delta_path) {
- from = _alpm_filecache_find(d->from);
+ from = _alpm_filecache_find(handle, d->from);
} else {
/* len = cachedir len + from len + '/' + null */
len = strlen(cachedir) + strlen(d->from) + 2;
- CALLOC(from, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, 1));
+ CALLOC(from, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, 1));
snprintf(from, len, "%s/%s", cachedir, d->from);
}
len = strlen(cachedir) + strlen(d->to) + 2;
- CALLOC(to, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, 1));
+ CALLOC(to, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, 1));
snprintf(to, len, "%s/%s", cachedir, d->to);
/* build the patch command */
@@ -625,13 +635,13 @@ static int apply_deltas(pmtrans_t *trans)
snprintf(command, PATH_MAX, "xdelta3 -d -q -s %s %s %s", from, delta, to);
}
- _alpm_log(PM_LOG_DEBUG, "command: %s\n", command);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "command: %s\n", command);
- EVENT(trans, PM_TRANS_EVT_DELTA_PATCH_START, d->to, d->delta);
+ EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCH_START, d->to, d->delta);
int retval = system(command);
if(retval == 0) {
- EVENT(trans, PM_TRANS_EVT_DELTA_PATCH_DONE, NULL, NULL);
+ EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCH_DONE, NULL, NULL);
/* delete the delta file */
unlink(delta);
@@ -649,14 +659,15 @@ static int apply_deltas(pmtrans_t *trans)
if(retval != 0) {
/* one delta failed for this package, cancel the remaining ones */
- EVENT(trans, PM_TRANS_EVT_DELTA_PATCH_FAILED, NULL, NULL);
+ EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCH_FAILED, NULL, NULL);
+ handle->pm_errno = ALPM_ERR_DLT_PATCHFAILED;
ret = 1;
break;
}
}
}
- return(ret);
+ return ret;
}
/** Compares the md5sum of a file to the expected value.
@@ -665,50 +676,73 @@ static int apply_deltas(pmtrans_t *trans)
* should be deleted.
*
* @param trans the transaction
- * @param filename the filename of the file to test
+ * @param filename the absolute path of the file to test
* @param md5sum the expected md5sum of the file
*
* @return 0 if the md5sum matched, 1 if not, -1 in case of errors
*/
-static int test_md5sum(pmtrans_t *trans, const char *filename,
+static int test_md5sum(alpm_trans_t *trans, const char *filepath,
const char *md5sum)
{
- char *filepath;
- int ret;
-
- filepath = _alpm_filecache_find(filename);
-
- ret = _alpm_test_md5sum(filepath, md5sum);
-
+ int ret = _alpm_test_md5sum(filepath, md5sum);
if(ret == 1) {
int doremove = 0;
- QUESTION(trans, PM_TRANS_CONV_CORRUPTED_PKG, (char *)filename,
+ QUESTION(trans, ALPM_TRANS_CONV_CORRUPTED_PKG, (char *)filepath,
NULL, NULL, &doremove);
if(doremove) {
unlink(filepath);
}
}
- FREE(filepath);
-
- return(ret);
+ return ret;
}
-int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
+static int validate_deltas(alpm_handle_t *handle, alpm_list_t *deltas,
+ alpm_list_t **data)
{
- alpm_list_t *i, *j, *files = NULL;
- alpm_list_t *deltas = NULL;
- size_t numtargs, current = 0, replaces = 0;
- int errors = 0;
- const char *cachedir = NULL;
- int ret = -1;
+ int errors = 0, ret = 0;
+ alpm_list_t *i;
+ alpm_trans_t *trans = handle->trans;
- ALPM_LOG_FUNC;
+ if(!deltas) {
+ return 0;
+ }
+
+ /* Check integrity of deltas */
+ EVENT(trans, ALPM_TRANS_EVT_DELTA_INTEGRITY_START, NULL, NULL);
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
+ for(i = deltas; i; i = i->next) {
+ alpm_delta_t *d = alpm_list_getdata(i);
+ char *filepath = _alpm_filecache_find(handle, d->delta);
- cachedir = _alpm_filecache_setup();
- trans->state = STATE_DOWNLOADING;
+ if(test_md5sum(trans, filepath, d->delta_md5) != 0) {
+ errors++;
+ *data = alpm_list_add(*data, strdup(d->delta));
+ }
+ FREE(filepath);
+ }
+ if(errors) {
+ handle->pm_errno = ALPM_ERR_DLT_INVALID;
+ return -1;
+ }
+ EVENT(trans, ALPM_TRANS_EVT_DELTA_INTEGRITY_DONE, NULL, NULL);
+
+ /* Use the deltas to generate the packages */
+ EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCHES_START, NULL, NULL);
+ ret = apply_deltas(handle);
+ EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCHES_DONE, NULL, NULL);
+ return ret;
+}
+
+static int download_files(alpm_handle_t *handle, alpm_list_t **deltas)
+{
+ const char *cachedir;
+ alpm_list_t *i, *j;
+ alpm_list_t *files = NULL;
+ int errors = 0;
+
+ cachedir = _alpm_filecache_setup(handle);
+ handle->trans->state = STATE_DOWNLOADING;
/* Total progress - figure out the total download size if required to
* pass to the callback. This function is called once, and it is up to the
@@ -716,8 +750,8 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
if(handle->totaldlcb) {
off_t total_size = (off_t)0;
/* sum up the download size for each package and store total */
- for(i = trans->add; i; i = i->next) {
- pmpkg_t *spkg = i->data;
+ for(i = handle->trans->add; i; i = i->next) {
+ alpm_pkg_t *spkg = i->data;
total_size += spkg->download_size;
}
handle->totaldlcb(total_size);
@@ -725,62 +759,88 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
/* group sync records by repository and download */
for(i = handle->dbs_sync; i; i = i->next) {
- pmdb_t *current = i->data;
+ alpm_db_t *current = i->data;
- for(j = trans->add; j; j = j->next) {
- pmpkg_t *spkg = j->data;
+ for(j = handle->trans->add; j; j = j->next) {
+ alpm_pkg_t *spkg = j->data;
if(spkg->origin != PKG_FROM_FILE && current == spkg->origin_data.db) {
- const char *fname = NULL;
-
- fname = alpm_pkg_get_filename(spkg);
- ASSERT(fname != NULL, RET_ERR(PM_ERR_PKG_INVALID_NAME, -1));
alpm_list_t *delta_path = spkg->delta_path;
if(delta_path) {
/* using deltas */
- alpm_list_t *dlts = NULL;
-
+ alpm_list_t *dlts;
for(dlts = delta_path; dlts; dlts = dlts->next) {
- pmdelta_t *d = dlts->data;
+ alpm_delta_t *delta = dlts->data;
+ if(delta->download_size != 0) {
+ struct dload_payload *dpayload;
- if(d->download_size != 0) {
- /* add the delta filename to the download list if needed */
- files = alpm_list_add(files, strdup(d->delta));
- }
+ CALLOC(dpayload, 1, sizeof(*dpayload), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+ STRDUP(dpayload->filename, delta->delta, RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+ dpayload->max_size = delta->download_size;
+ files = alpm_list_add(files, dpayload);
+ }
/* keep a list of all the delta files for md5sums */
- deltas = alpm_list_add(deltas, d);
+ *deltas = alpm_list_add(*deltas, delta);
}
- } else {
- /* not using deltas */
- if(spkg->download_size != 0) {
- /* add the filename to the download list if needed */
- files = alpm_list_add(files, strdup(fname));
- }
+ } else if(spkg->download_size != 0) {
+ struct dload_payload *payload;
+
+ ASSERT(spkg->filename != NULL, RET_ERR(handle, ALPM_ERR_PKG_INVALID_NAME, -1));
+ CALLOC(payload, 1, sizeof(*payload), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+ STRDUP(payload->filename, spkg->filename, RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+ payload->max_size = alpm_pkg_get_size(spkg);
+
+ files = alpm_list_add(files, payload);
}
}
}
if(files) {
- EVENT(trans, PM_TRANS_EVT_RETRIEVE_START, current->treename, NULL);
- errors = _alpm_download_files(files, current->servers, cachedir);
+ EVENT(handle->trans, ALPM_TRANS_EVT_RETRIEVE_START, current->treename, NULL);
+ for(j = files; j; j = j->next) {
+ struct dload_payload *payload = j->data;
+ alpm_list_t *server;
+ int ret = -1;
+ for(server = current->servers; server; server = server->next) {
+ const char *server_url = server->data;
+ size_t len;
+
+ /* print server + filename into a buffer */
+ len = strlen(server_url) + strlen(payload->filename) + 2;
+ CALLOC(payload->fileurl, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+ snprintf(payload->fileurl, len, "%s/%s", server_url, payload->filename);
+ payload->handle = handle;
+ payload->allow_resume = 1;
+
+ ret = _alpm_download(payload, cachedir, NULL);
+ if(ret != -1) {
+ break;
+ }
+ }
+ if(ret == -1) {
+ errors++;
+ }
+ }
- if (errors) {
- _alpm_log(PM_LOG_WARNING, _("failed to retrieve some files from %s\n"),
+ alpm_list_free_inner(files, (alpm_list_fn_free)_alpm_dload_payload_free);
+ alpm_list_free(files);
+ files = NULL;
+ if(errors) {
+ _alpm_log(handle, ALPM_LOG_WARNING, _("failed to retrieve some files from %s\n"),
current->treename);
- if(pm_errno == 0) {
- pm_errno = PM_ERR_RETRIEVE;
+ if(handle->pm_errno == 0) {
+ handle->pm_errno = ALPM_ERR_RETRIEVE;
}
- goto error;
+ return -1;
}
- FREELIST(files);
}
}
- for(j = trans->add; j; j = j->next) {
- pmpkg_t *pkg = j->data;
+ for(j = handle->trans->add; j; j = j->next) {
+ alpm_pkg_t *pkg = j->data;
pkg->infolevel &= ~INFRQ_DSIZE;
pkg->download_size = 0;
}
@@ -789,70 +849,60 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
if(handle->totaldlcb) {
handle->totaldlcb(0);
}
+ return 0;
+}
- /* if we have deltas to work with */
- if(handle->usedelta && deltas) {
- int ret = 0;
- errors = 0;
- /* Check integrity of deltas */
- EVENT(trans, PM_TRANS_EVT_DELTA_INTEGRITY_START, NULL, NULL);
-
- for(i = deltas; i; i = i->next) {
- pmdelta_t *d = alpm_list_getdata(i);
- const char *filename = alpm_delta_get_filename(d);
- const char *md5sum = alpm_delta_get_md5sum(d);
-
- if(test_md5sum(trans, filename, md5sum) != 0) {
- errors++;
- *data = alpm_list_add(*data, strdup(filename));
- }
- }
- if(errors) {
- pm_errno = PM_ERR_DLT_INVALID;
- goto error;
- }
- EVENT(trans, PM_TRANS_EVT_DELTA_INTEGRITY_DONE, NULL, NULL);
+int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
+{
+ alpm_list_t *i;
+ alpm_list_t *deltas = NULL;
+ size_t numtargs, current = 0, replaces = 0;
+ int errors;
+ alpm_trans_t *trans = handle->trans;
- /* Use the deltas to generate the packages */
- EVENT(trans, PM_TRANS_EVT_DELTA_PATCHES_START, NULL, NULL);
- ret = apply_deltas(trans);
- EVENT(trans, PM_TRANS_EVT_DELTA_PATCHES_DONE, NULL, NULL);
+ if(download_files(handle, &deltas)) {
+ alpm_list_free(deltas);
+ return -1;
+ }
- if(ret) {
- pm_errno = PM_ERR_DLT_PATCHFAILED;
- goto error;
- }
+ if(validate_deltas(handle, deltas, data)) {
+ alpm_list_free(deltas);
+ return -1;
}
+ alpm_list_free(deltas);
/* Check integrity of packages */
numtargs = alpm_list_count(trans->add);
- EVENT(trans, PM_TRANS_EVT_INTEGRITY_START, NULL, NULL);
+ EVENT(trans, ALPM_TRANS_EVT_INTEGRITY_START, NULL, NULL);
errors = 0;
+
for(i = trans->add; i; i = i->next, current++) {
- pmpkg_t *spkg = i->data;
+ alpm_pkg_t *spkg = i->data;
int percent = (current * 100) / numtargs;
+ const char *filename;
+ char *filepath;
+ alpm_siglevel_t level;
+
+ PROGRESS(trans, ALPM_TRANS_PROGRESS_INTEGRITY_START, "", percent,
+ numtargs, current);
if(spkg->origin == PKG_FROM_FILE) {
continue; /* pkg_load() has been already called, this package is valid */
}
- PROGRESS(trans, PM_TRANS_PROGRESS_INTEGRITY_START, "", percent,
- numtargs, current);
- const char *filename = alpm_pkg_get_filename(spkg);
- const char *md5sum = alpm_pkg_get_md5sum(spkg);
+ filename = alpm_pkg_get_filename(spkg);
+ filepath = _alpm_filecache_find(handle, filename);
+ alpm_db_t *sdb = alpm_pkg_get_db(spkg);
+ level = alpm_db_get_siglevel(sdb);
- if(test_md5sum(trans, filename, md5sum) != 0) {
- errors++;
- *data = alpm_list_add(*data, strdup(filename));
- continue;
- }
/* load the package file and replace pkgcache entry with it in the target list */
/* TODO: alpm_pkg_get_db() will not work on this target anymore */
- _alpm_log(PM_LOG_DEBUG, "replacing pkgcache entry with package file for target %s\n", spkg->name);
- char *filepath = _alpm_filecache_find(filename);
- pmpkg_t *pkgfile;
- if(alpm_pkg_load(filepath, 1, &pkgfile) != 0) {
- _alpm_pkg_free(pkgfile);
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "replacing pkgcache entry with package file for target %s\n",
+ spkg->name);
+ alpm_pkg_t *pkgfile =_alpm_pkg_load_internal(handle, filepath, 1, spkg->md5sum,
+ spkg->base64_sig, level);
+ if(!pkgfile) {
errors++;
*data = alpm_list_add(*data, strdup(filename));
FREE(filepath);
@@ -863,17 +913,18 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
i->data = pkgfile;
_alpm_pkg_free_trans(spkg); /* spkg has been removed from the target list */
}
- PROGRESS(trans, PM_TRANS_PROGRESS_INTEGRITY_START, "", 100,
+
+ PROGRESS(trans, ALPM_TRANS_PROGRESS_INTEGRITY_START, "", 100,
numtargs, current);
- EVENT(trans, PM_TRANS_EVT_INTEGRITY_DONE, NULL, NULL);
+ EVENT(trans, ALPM_TRANS_EVT_INTEGRITY_DONE, NULL, NULL);
+
+
if(errors) {
- pm_errno = PM_ERR_PKG_INVALID;
- goto error;
+ RET_ERR(handle, ALPM_ERR_PKG_INVALID, -1);
}
- if(trans->flags & PM_TRANS_FLAG_DOWNLOADONLY) {
- ret = 0;
- goto error;
+ if(trans->flags & ALPM_TRANS_FLAG_DOWNLOADONLY) {
+ return 0;
}
trans->state = STATE_COMMITING;
@@ -881,61 +932,56 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
replaces = alpm_list_count(trans->remove);
/* fileconflict check */
- if(!(trans->flags & PM_TRANS_FLAG_FORCE)) {
- EVENT(trans, PM_TRANS_EVT_FILECONFLICTS_START, NULL, NULL);
+ if(!(trans->flags & ALPM_TRANS_FLAG_FORCE)) {
+ EVENT(trans, ALPM_TRANS_EVT_FILECONFLICTS_START, NULL, NULL);
- _alpm_log(PM_LOG_DEBUG, "looking for file conflicts\n");
- alpm_list_t *conflict = _alpm_db_find_fileconflicts(db_local, trans,
- trans->add, trans->remove);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "looking for file conflicts\n");
+ alpm_list_t *conflict = _alpm_db_find_fileconflicts(handle,
+ trans->add, trans->remove);
if(conflict) {
- pm_errno = PM_ERR_FILE_CONFLICTS;
if(data) {
*data = conflict;
} else {
alpm_list_free_inner(conflict, (alpm_list_fn_free)_alpm_fileconflict_free);
alpm_list_free(conflict);
}
- goto error;
+ RET_ERR(handle, ALPM_ERR_FILE_CONFLICTS, -1);
}
- EVENT(trans, PM_TRANS_EVT_FILECONFLICTS_DONE, NULL, NULL);
+ EVENT(trans, ALPM_TRANS_EVT_FILECONFLICTS_DONE, NULL, NULL);
}
/* check available disk space */
if(handle->checkspace) {
- EVENT(trans, PM_TRANS_EVT_DISKSPACE_START, NULL, NULL);
+ EVENT(trans, ALPM_TRANS_EVT_DISKSPACE_START, NULL, NULL);
- _alpm_log(PM_LOG_DEBUG, "checking available disk space\n");
- if(_alpm_check_diskspace(trans, handle->db_local) == -1) {
- _alpm_log(PM_LOG_ERROR, "%s\n", _("not enough free disk space"));
- goto error;
+ _alpm_log(handle, ALPM_LOG_DEBUG, "checking available disk space\n");
+ if(_alpm_check_diskspace(handle) == -1) {
+ _alpm_log(handle, ALPM_LOG_ERROR, "%s\n", _("not enough free disk space"));
+ return -1;
}
- EVENT(trans, PM_TRANS_EVT_DISKSPACE_DONE, NULL, NULL);
+ EVENT(trans, ALPM_TRANS_EVT_DISKSPACE_DONE, NULL, NULL);
}
/* remove conflicting and to-be-replaced packages */
if(replaces) {
- _alpm_log(PM_LOG_DEBUG, "removing conflicting and to-be-replaced packages\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "removing conflicting and to-be-replaced packages\n");
/* we want the frontend to be aware of commit details */
- if(_alpm_remove_packages(trans, handle->db_local) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not commit removal transaction\n"));
- goto error;
+ if(_alpm_remove_packages(handle) == -1) {
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not commit removal transaction\n"));
+ return -1;
}
}
/* install targets */
- _alpm_log(PM_LOG_DEBUG, "installing packages\n");
- if(_alpm_upgrade_packages(trans, handle->db_local) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not commit transaction\n"));
- goto error;
+ _alpm_log(handle, ALPM_LOG_DEBUG, "installing packages\n");
+ if(_alpm_upgrade_packages(handle) == -1) {
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not commit transaction\n"));
+ return -1;
}
- ret = 0;
-error:
- FREELIST(files);
- alpm_list_free(deltas);
- return(ret);
+ return 0;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/sync.h b/lib/libalpm/sync.h
index 90a2d40d..472d1dfc 100644
--- a/lib/libalpm/sync.h
+++ b/lib/libalpm/sync.h
@@ -24,8 +24,8 @@
#include "alpm.h"
-int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync, alpm_list_t **data);
-int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data);
+int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data);
+int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data);
#endif /* _ALPM_SYNC_H */
diff --git a/lib/libalpm/trans.c b/lib/libalpm/trans.c
index bf9ef722..1bab830d 100644
--- a/lib/libalpm/trans.c
+++ b/lib/libalpm/trans.c
@@ -28,11 +28,8 @@
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/statvfs.h>
#include <errno.h>
#include <limits.h>
-#include <fcntl.h>
/* libalpm */
#include "trans.h"
@@ -41,91 +38,34 @@
#include "util.h"
#include "log.h"
#include "handle.h"
-#include "add.h"
#include "remove.h"
#include "sync.h"
#include "alpm.h"
-#include "deps.h"
/** \addtogroup alpm_trans Transaction Functions
* @brief Functions to manipulate libalpm transactions
* @{
*/
-/* Create a lock file */
-static int make_lock(pmhandle_t *handle)
-{
- int fd;
- char *dir, *ptr;
-
- ASSERT(handle->lockfile != NULL, return -1);
-
- /* create the dir of the lockfile first */
- dir = strdup(handle->lockfile);
- ptr = strrchr(dir, '/');
- if(ptr) {
- *ptr = '\0';
- }
- if(_alpm_makepath(dir)) {
- FREE(dir);
- return(-1);
- }
- FREE(dir);
-
- do {
- fd = open(handle->lockfile, O_WRONLY | O_CREAT | O_EXCL, 0000);
- } while (fd == -1 && errno == EINTR);
- if(fd > 0) {
- FILE *f = fdopen(fd, "w");
- fprintf(f, "%ld\n", (long)getpid());
- fflush(f);
- fsync(fd);
- handle->lckstream = f;
- return(0);
- }
- return(-1);
-}
-
-/* Remove a lock file */
-static int remove_lock(pmhandle_t *handle)
-{
- if(handle->lckstream != NULL) {
- fclose(handle->lckstream);
- handle->lckstream = NULL;
- }
- if(unlink(handle->lockfile) == -1 && errno != ENOENT) {
- return(-1);
- }
- return(0);
-}
-
/** Initialize the transaction. */
-int SYMEXPORT alpm_trans_init(pmtransflag_t flags,
+int SYMEXPORT alpm_trans_init(alpm_handle_t *handle, alpm_transflag_t flags,
alpm_trans_cb_event event, alpm_trans_cb_conv conv,
alpm_trans_cb_progress progress)
{
- pmtrans_t *trans;
- const int required_db_version = 2;
- int db_version;
-
- ALPM_LOG_FUNC;
+ alpm_trans_t *trans;
/* Sanity checks */
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
- ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
+ ASSERT(handle->trans == NULL, RET_ERR(handle, ALPM_ERR_TRANS_NOT_NULL, -1));
/* lock db */
- if(!(flags & PM_TRANS_FLAG_NOLOCK)) {
- if(make_lock(handle)) {
- RET_ERR(PM_ERR_HANDLE_LOCK, -1);
+ if(!(flags & ALPM_TRANS_FLAG_NOLOCK)) {
+ if(_alpm_handle_lock(handle)) {
+ RET_ERR(handle, ALPM_ERR_HANDLE_LOCK, -1);
}
}
- trans = _alpm_trans_new();
- if(trans == NULL) {
- RET_ERR(PM_ERR_MEMORY, -1);
- }
-
+ CALLOC(trans, 1, sizeof(alpm_trans_t), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
trans->flags = flags;
trans->cb_event = event;
trans->cb_conv = conv;
@@ -134,201 +74,169 @@ int SYMEXPORT alpm_trans_init(pmtransflag_t flags,
handle->trans = trans;
- /* check database version */
- db_version = _alpm_db_version(handle->db_local);
- if(db_version < required_db_version) {
- _alpm_log(PM_LOG_ERROR,
- _("%s database version is too old\n"), handle->db_local->treename);
- remove_lock(handle);
- _alpm_trans_free(trans);
- RET_ERR(PM_ERR_DB_VERSION, -1);
- }
-
- return(0);
+ return 0;
}
-static alpm_list_t *check_arch(alpm_list_t *pkgs)
+static alpm_list_t *check_arch(alpm_handle_t *handle, alpm_list_t *pkgs)
{
alpm_list_t *i;
alpm_list_t *invalid = NULL;
- const char *arch = alpm_option_get_arch();
+ const char *arch = alpm_option_get_arch(handle);
if(!arch) {
- return(NULL);
+ return NULL;
}
for(i = pkgs; i; i = i->next) {
- pmpkg_t *pkg = i->data;
+ alpm_pkg_t *pkg = i->data;
const char *pkgarch = alpm_pkg_get_arch(pkg);
if(pkgarch && strcmp(pkgarch, arch) && strcmp(pkgarch, "any")) {
char *string;
const char *pkgname = alpm_pkg_get_name(pkg);
const char *pkgver = alpm_pkg_get_version(pkg);
size_t len = strlen(pkgname) + strlen(pkgver) + strlen(pkgarch) + 3;
- MALLOC(string, len, RET_ERR(PM_ERR_MEMORY, invalid));
+ MALLOC(string, len, RET_ERR(handle, ALPM_ERR_MEMORY, invalid));
sprintf(string, "%s-%s-%s", pkgname, pkgver, pkgarch);
invalid = alpm_list_add(invalid, string);
}
}
- return(invalid);
+ return invalid;
}
/** Prepare a transaction. */
-int SYMEXPORT alpm_trans_prepare(alpm_list_t **data)
+int SYMEXPORT alpm_trans_prepare(alpm_handle_t *handle, alpm_list_t **data)
{
- pmtrans_t *trans;
-
- ALPM_LOG_FUNC;
+ alpm_trans_t *trans;
/* Sanity checks */
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
- ASSERT(data != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
+ CHECK_HANDLE(handle, return -1);
+ ASSERT(data != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -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 != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
+ ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1));
/* If there's nothing to do, return without complaining */
if(trans->add == NULL && trans->remove == NULL) {
- return(0);
+ return 0;
}
- alpm_list_t *invalid = check_arch(trans->add);
+ alpm_list_t *invalid = check_arch(handle, trans->add);
if(invalid) {
if(data) {
*data = invalid;
}
- RET_ERR(PM_ERR_PKG_INVALID_ARCH, -1);
+ RET_ERR(handle, ALPM_ERR_PKG_INVALID_ARCH, -1);
}
if(trans->add == NULL) {
- if(_alpm_remove_prepare(trans, handle->db_local, data) == -1) {
+ if(_alpm_remove_prepare(handle, data) == -1) {
/* pm_errno is set by _alpm_remove_prepare() */
- return(-1);
+ return -1;
}
} else {
- if(_alpm_sync_prepare(trans, handle->db_local, handle->dbs_sync, data) == -1) {
+ if(_alpm_sync_prepare(handle, data) == -1) {
/* pm_errno is set by _alpm_sync_prepare() */
- return(-1);
+ return -1;
}
}
trans->state = STATE_PREPARED;
- return(0);
+ return 0;
}
/** Commit a transaction. */
-int SYMEXPORT alpm_trans_commit(alpm_list_t **data)
+int SYMEXPORT alpm_trans_commit(alpm_handle_t *handle, alpm_list_t **data)
{
- pmtrans_t *trans;
-
- ALPM_LOG_FUNC;
+ alpm_trans_t *trans;
/* Sanity checks */
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
trans = handle->trans;
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
- ASSERT(trans->state == STATE_PREPARED, RET_ERR(PM_ERR_TRANS_NOT_PREPARED, -1));
+ ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
+ ASSERT(trans->state == STATE_PREPARED, RET_ERR(handle, ALPM_ERR_TRANS_NOT_PREPARED, -1));
- ASSERT(!(trans->flags & PM_TRANS_FLAG_NOLOCK), RET_ERR(PM_ERR_TRANS_NOT_LOCKED, -1));
+ ASSERT(!(trans->flags & ALPM_TRANS_FLAG_NOLOCK), RET_ERR(handle, ALPM_ERR_TRANS_NOT_LOCKED, -1));
/* If there's nothing to do, return without complaining */
if(trans->add == NULL && trans->remove == NULL) {
- return(0);
+ return 0;
}
trans->state = STATE_COMMITING;
if(trans->add == NULL) {
- if(_alpm_remove_packages(trans, handle->db_local) == -1) {
+ if(_alpm_remove_packages(handle) == -1) {
/* pm_errno is set by _alpm_remove_commit() */
- return(-1);
+ return -1;
}
} else {
- if(_alpm_sync_commit(trans, handle->db_local, data) == -1) {
+ if(_alpm_sync_commit(handle, data) == -1) {
/* pm_errno is set by _alpm_sync_commit() */
- return(-1);
+ return -1;
}
}
trans->state = STATE_COMMITED;
- return(0);
+ return 0;
}
/** Interrupt a transaction. */
-int SYMEXPORT alpm_trans_interrupt(void)
+int SYMEXPORT alpm_trans_interrupt(alpm_handle_t *handle)
{
- pmtrans_t *trans;
-
- ALPM_LOG_FUNC;
+ alpm_trans_t *trans;
/* Sanity checks */
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
trans = handle->trans;
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
+ ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
ASSERT(trans->state == STATE_COMMITING || trans->state == STATE_INTERRUPTED,
- RET_ERR(PM_ERR_TRANS_TYPE, -1));
+ RET_ERR(handle, ALPM_ERR_TRANS_TYPE, -1));
trans->state = STATE_INTERRUPTED;
- return(0);
+ return 0;
}
/** Release a transaction. */
-int SYMEXPORT alpm_trans_release(void)
+int SYMEXPORT alpm_trans_release(alpm_handle_t *handle)
{
- pmtrans_t *trans;
-
- ALPM_LOG_FUNC;
+ alpm_trans_t *trans;
/* Sanity checks */
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
trans = handle->trans;
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
- ASSERT(trans->state != STATE_IDLE, RET_ERR(PM_ERR_TRANS_NULL, -1));
+ ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
+ ASSERT(trans->state != STATE_IDLE, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
- int nolock_flag = trans->flags & PM_TRANS_FLAG_NOLOCK;
+ int nolock_flag = trans->flags & ALPM_TRANS_FLAG_NOLOCK;
_alpm_trans_free(trans);
handle->trans = NULL;
/* unlock db */
if(!nolock_flag) {
- if(remove_lock(handle)) {
- _alpm_log(PM_LOG_WARNING, _("could not remove lock file %s\n"),
- alpm_option_get_lockfile());
- alpm_logaction("warning: could not remove lock file %s\n",
- alpm_option_get_lockfile());
+ if(_alpm_handle_unlock(handle)) {
+ _alpm_log(handle, ALPM_LOG_WARNING, _("could not remove lock file %s\n"),
+ alpm_option_get_lockfile(handle));
+ alpm_logaction(handle, "warning: could not remove lock file %s\n",
+ alpm_option_get_lockfile(handle));
}
}
- return(0);
+ return 0;
}
/** @} */
-pmtrans_t *_alpm_trans_new(void)
+void _alpm_trans_free(alpm_trans_t *trans)
{
- pmtrans_t *trans;
-
- ALPM_LOG_FUNC;
-
- CALLOC(trans, 1, sizeof(pmtrans_t), RET_ERR(PM_ERR_MEMORY, NULL));
- trans->state = STATE_IDLE;
-
- return(trans);
-}
-
-void _alpm_trans_free(pmtrans_t *trans)
-{
- ALPM_LOG_FUNC;
-
if(trans == NULL) {
return;
}
@@ -351,7 +259,7 @@ static int grep(const char *fn, const char *needle)
FILE *fp;
if((fp = fopen(fn, "r")) == NULL) {
- return(0);
+ return 0;
}
while(!feof(fp)) {
char line[1024];
@@ -362,16 +270,15 @@ static int grep(const char *fn, const char *needle)
* ends up being split across line reads */
if(strstr(line, needle)) {
fclose(fp);
- return(1);
+ return 1;
}
}
fclose(fp);
- return(0);
+ return 0;
}
-int _alpm_runscriptlet(const char *root, const char *installfn,
- const char *script, const char *ver,
- const char *oldver, pmtrans_t *trans)
+int _alpm_runscriptlet(alpm_handle_t *handle, const char *installfn,
+ const char *script, const char *ver, const char *oldver)
{
char scriptfn[PATH_MAX];
char cmdline[PATH_MAX];
@@ -381,23 +288,20 @@ int _alpm_runscriptlet(const char *root, const char *installfn,
int clean_tmpdir = 0;
int retval = 0;
- ALPM_LOG_FUNC;
-
- if(access(installfn, R_OK)) {
- /* not found */
- _alpm_log(PM_LOG_DEBUG, "scriptlet '%s' not found\n", installfn);
- return(0);
+ if(_alpm_access(handle, NULL, installfn, R_OK) != 0) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "scriptlet '%s' not found\n", installfn);
+ return 0;
}
/* creates a directory in $root/tmp/ for copying/extracting the scriptlet */
- snprintf(tmpdir, PATH_MAX, "%stmp/", root);
+ snprintf(tmpdir, PATH_MAX, "%stmp/", handle->root);
if(access(tmpdir, F_OK) != 0) {
_alpm_makepath_mode(tmpdir, 01777);
}
- snprintf(tmpdir, PATH_MAX, "%stmp/alpm_XXXXXX", root);
+ snprintf(tmpdir, PATH_MAX, "%stmp/alpm_XXXXXX", handle->root);
if(mkdtemp(tmpdir) == NULL) {
- _alpm_log(PM_LOG_ERROR, _("could not create temp directory\n"));
- return(1);
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not create temp directory\n"));
+ return 1;
} else {
clean_tmpdir = 1;
}
@@ -405,12 +309,12 @@ int _alpm_runscriptlet(const char *root, const char *installfn,
/* either extract or copy the scriptlet */
snprintf(scriptfn, PATH_MAX, "%s/.INSTALL", tmpdir);
if(strcmp(script, "pre_upgrade") == 0 || strcmp(script, "pre_install") == 0) {
- if(_alpm_unpack_single(installfn, tmpdir, ".INSTALL")) {
+ if(_alpm_unpack_single(handle, installfn, tmpdir, ".INSTALL")) {
retval = 1;
}
} else {
if(_alpm_copyfile(installfn, scriptfn)) {
- _alpm_log(PM_LOG_ERROR, _("could not copy tempfile to %s (%s)\n"), scriptfn, strerror(errno));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not copy tempfile to %s (%s)\n"), scriptfn, strerror(errno));
retval = 1;
}
}
@@ -419,7 +323,7 @@ int _alpm_runscriptlet(const char *root, const char *installfn,
}
/* chop off the root so we can find the tmpdir in the chroot */
- scriptpath = scriptfn + strlen(root) - 1;
+ scriptpath = scriptfn + strlen(handle->root) - 1;
if(!grep(scriptfn, script)) {
/* script not found in scriptlet file */
@@ -434,41 +338,41 @@ int _alpm_runscriptlet(const char *root, const char *installfn,
scriptpath, script, ver);
}
- _alpm_log(PM_LOG_DEBUG, "executing \"%s\"\n", cmdline);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "executing \"%s\"\n", cmdline);
- retval = _alpm_run_chroot(root, "/bin/sh", argv);
+ retval = _alpm_run_chroot(handle, "/bin/sh", argv);
cleanup:
if(clean_tmpdir && _alpm_rmrf(tmpdir)) {
- _alpm_log(PM_LOG_WARNING, _("could not remove tmpdir %s\n"), tmpdir);
+ _alpm_log(handle, ALPM_LOG_WARNING, _("could not remove tmpdir %s\n"), tmpdir);
}
- return(retval);
+ return retval;
}
-int SYMEXPORT alpm_trans_get_flags()
+alpm_transflag_t SYMEXPORT alpm_trans_get_flags(alpm_handle_t *handle)
{
/* Sanity checks */
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
- ASSERT(handle->trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
+ ASSERT(handle->trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
return handle->trans->flags;
}
-alpm_list_t SYMEXPORT * alpm_trans_get_add()
+alpm_list_t SYMEXPORT *alpm_trans_get_add(alpm_handle_t *handle)
{
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(handle->trans != NULL, return(NULL));
+ CHECK_HANDLE(handle, return NULL);
+ ASSERT(handle->trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, NULL));
return handle->trans->add;
}
-alpm_list_t SYMEXPORT * alpm_trans_get_remove()
+alpm_list_t SYMEXPORT *alpm_trans_get_remove(alpm_handle_t *handle)
{
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(handle->trans != NULL, return(NULL));
+ CHECK_HANDLE(handle, return NULL);
+ ASSERT(handle->trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, NULL));
return handle->trans->remove;
}
diff --git a/lib/libalpm/trans.h b/lib/libalpm/trans.h
index 6702881b..9a60e71b 100644
--- a/lib/libalpm/trans.h
+++ b/lib/libalpm/trans.h
@@ -25,7 +25,7 @@
#include "alpm.h"
-typedef enum _pmtransstate_t {
+typedef enum _alpm_transstate_t {
STATE_IDLE = 0,
STATE_INITIALIZED,
STATE_PREPARED,
@@ -33,14 +33,14 @@ typedef enum _pmtransstate_t {
STATE_COMMITING,
STATE_COMMITED,
STATE_INTERRUPTED
-} pmtransstate_t;
+} alpm_transstate_t;
/* Transaction */
-struct __pmtrans_t {
- pmtransflag_t flags;
- pmtransstate_t state;
- alpm_list_t *add; /* list of (pmpkg_t *) */
- alpm_list_t *remove; /* list of (pmpkg_t *) */
+struct __alpm_trans_t {
+ alpm_transflag_t flags;
+ alpm_transstate_t state;
+ alpm_list_t *add; /* list of (alpm_pkg_t *) */
+ alpm_list_t *remove; /* list of (alpm_pkg_t *) */
alpm_list_t *skip_remove; /* list of (char *) */
alpm_trans_cb_event cb_event;
alpm_trans_cb_conv cb_conv;
@@ -66,14 +66,12 @@ do { \
} \
} while(0)
-pmtrans_t *_alpm_trans_new(void);
-void _alpm_trans_free(pmtrans_t *trans);
-int _alpm_trans_init(pmtrans_t *trans, pmtransflag_t flags,
+void _alpm_trans_free(alpm_trans_t *trans);
+int _alpm_trans_init(alpm_trans_t *trans, alpm_transflag_t flags,
alpm_trans_cb_event event, alpm_trans_cb_conv conv,
alpm_trans_cb_progress progress);
-int _alpm_runscriptlet(const char *root, const char *installfn,
- const char *script, const char *ver,
- const char *oldver, pmtrans_t *trans);
+int _alpm_runscriptlet(alpm_handle_t *handle, const char *installfn,
+ const char *script, const char *ver, const char *oldver);
#endif /* _ALPM_TRANS_H */
diff --git a/lib/libalpm/util.c b/lib/libalpm/util.c
index 430da92a..123cd24e 100644
--- a/lib/libalpm/util.c
+++ b/lib/libalpm/util.c
@@ -53,10 +53,10 @@
/* libalpm */
#include "util.h"
#include "log.h"
-#include "package.h"
#include "alpm.h"
#include "alpm_list.h"
#include "handle.h"
+#include "trans.h"
#ifndef HAVE_STRSEP
/* This is a replacement for strsep which is not portable (missing on Solaris).
@@ -65,14 +65,14 @@ char* strsep(char** str, const char* delims)
{
char* token;
- if (*str==NULL) {
+ if(*str==NULL) {
/* No more tokens */
return NULL;
}
token=*str;
- while (**str!='\0') {
- if (strchr(delims,**str)!=NULL) {
+ while(**str!='\0') {
+ if(strchr(delims,**str)!=NULL) {
**str='\0';
(*str)++;
return token;
@@ -87,7 +87,7 @@ char* strsep(char** str, const char* delims)
int _alpm_makepath(const char *path)
{
- return(_alpm_makepath_mode(path, 0755));
+ return _alpm_makepath_mode(path, 0755);
}
/* does the same thing as 'mkdir -p' */
@@ -123,7 +123,7 @@ int _alpm_makepath_mode(const char *path, mode_t mode)
free(orig);
free(incr);
umask(oldmask);
- return(ret);
+ return ret;
}
#define CPBUFSIZE 8 * 1024
@@ -137,12 +137,12 @@ int _alpm_copyfile(const char *src, const char *dest)
in = fopen(src, "rb");
if(in == NULL) {
- return(1);
+ return 1;
}
out = fopen(dest, "wb");
if(out == NULL) {
fclose(in);
- return(1);
+ return 1;
}
CALLOC(buf, (size_t)CPBUFSIZE, (size_t)1, ret = 1; goto cleanup;);
@@ -152,9 +152,6 @@ int _alpm_copyfile(const char *src, const char *dest)
size_t nwritten = 0;
nwritten = fwrite(buf, 1, len, out);
if((nwritten != len) || ferror(out)) {
- pm_errno = PM_ERR_WRITE;
- _alpm_log(PM_LOG_ERROR, _("error writing to file '%s': %s\n"),
- dest, strerror(errno));
ret = -1;
goto cleanup;
}
@@ -175,7 +172,7 @@ cleanup:
fclose(in);
fclose(out);
FREE(buf);
- return(ret);
+ return ret;
}
/* Trim whitespace and newlines from a string
@@ -186,7 +183,7 @@ char *_alpm_strtrim(char *str)
if(*str == '\0') {
/* string is empty, so we're done. */
- return(str);
+ return str;
}
while(isspace((unsigned char)*pch)) {
@@ -198,7 +195,7 @@ char *_alpm_strtrim(char *str)
/* check if there wasn't anything but whitespace in the string. */
if(*str == '\0') {
- return(str);
+ return str;
}
pch = (str + (strlen(str) - 1));
@@ -207,7 +204,27 @@ char *_alpm_strtrim(char *str)
}
*++pch = '\0';
- return(str);
+ return str;
+}
+
+/**
+ * Trim trailing newline from a string (if one exists).
+ * @param str a single line of text
+ * @return the length of the trimmed string
+ */
+size_t _alpm_strip_newline(char *str)
+{
+ size_t len;
+ if(str == '\0') {
+ return 0;
+ }
+ len = strlen(str);
+ while(str[len - 1] == '\n') {
+ len--;
+ }
+ str[len] = '\0';
+
+ return len;
}
/* Compression functions */
@@ -215,36 +232,39 @@ char *_alpm_strtrim(char *str)
/**
* @brief Unpack a specific file in an archive.
*
- * @param archive the archive to unpack
- * @param prefix where to extract the files
- * @param fn a file within the archive to unpack
+ * @param handle the context handle
+ * @param archive the archive to unpack
+ * @param prefix where to extract the files
+ * @param filename a file within the archive to unpack
* @return 0 on success, 1 on failure
*/
-int _alpm_unpack_single(const char *archive, const char *prefix, const char *fn)
+int _alpm_unpack_single(alpm_handle_t *handle, const char *archive,
+ const char *prefix, const char *filename)
{
alpm_list_t *list = NULL;
int ret = 0;
- if(fn == NULL) {
- return(1);
+ if(filename == NULL) {
+ return 1;
}
- list = alpm_list_add(list, (void *)fn);
- ret = _alpm_unpack(archive, prefix, list, 1);
+ list = alpm_list_add(list, (void *)filename);
+ ret = _alpm_unpack(handle, archive, prefix, list, 1);
alpm_list_free(list);
- return(ret);
+ return ret;
}
/**
* @brief Unpack a list of files in an archive.
*
- * @param archive the archive to unpack
- * @param prefix where to extract the files
- * @param list a list of files within the archive to unpack or
- * NULL for all
+ * @param handle the context handle
+ * @param archive the archive to unpack
+ * @param prefix where to extract the files
+ * @param list a list of files within the archive to unpack or NULL for all
* @param breakfirst break after the first entry found
*
* @return 0 on success, 1 on failure
*/
-int _alpm_unpack(const char *archive, const char *prefix, alpm_list_t *list, int breakfirst)
+int _alpm_unpack(alpm_handle_t *handle, const char *archive, const char *prefix,
+ alpm_list_t *list, int breakfirst)
{
int ret = 0;
mode_t oldmask;
@@ -253,33 +273,33 @@ int _alpm_unpack(const char *archive, const char *prefix, alpm_list_t *list, int
char cwd[PATH_MAX];
int restore_cwd = 0;
- ALPM_LOG_FUNC;
-
- if((_archive = archive_read_new()) == NULL)
- RET_ERR(PM_ERR_LIBARCHIVE, 1);
+ if((_archive = archive_read_new()) == NULL) {
+ RET_ERR(handle, ALPM_ERR_LIBARCHIVE, 1);
+ }
archive_read_support_compression_all(_archive);
archive_read_support_format_all(_archive);
if(archive_read_open_filename(_archive, archive,
ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
- _alpm_log(PM_LOG_ERROR, _("could not open file %s: %s\n"), archive,
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"), archive,
archive_error_string(_archive));
- RET_ERR(PM_ERR_PKG_OPEN, 1);
+ RET_ERR(handle, ALPM_ERR_PKG_OPEN, 1);
}
oldmask = umask(0022);
/* save the cwd so we can restore it later */
if(getcwd(cwd, PATH_MAX) == NULL) {
- _alpm_log(PM_LOG_ERROR, _("could not get current working directory\n"));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not get current working directory\n"));
} else {
restore_cwd = 1;
}
/* just in case our cwd was removed in the upgrade operation */
if(chdir(prefix) != 0) {
- _alpm_log(PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), prefix, strerror(errno));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
+ prefix, strerror(errno));
ret = 1;
goto cleanup;
}
@@ -299,21 +319,21 @@ int _alpm_unpack(const char *archive, const char *prefix, alpm_list_t *list, int
/* If specific files were requested, skip entries that don't match. */
if(list) {
- char *prefix = strdup(entryname);
- char *p = strstr(prefix,"/");
+ char *entry_prefix = strdup(entryname);
+ char *p = strstr(entry_prefix,"/");
if(p) {
*(p+1) = '\0';
}
- char *found = alpm_list_find_str(list, prefix);
- free(prefix);
+ char *found = alpm_list_find_str(list, entry_prefix);
+ free(entry_prefix);
if(!found) {
- if (archive_read_data_skip(_archive) != ARCHIVE_OK) {
+ if(archive_read_data_skip(_archive) != ARCHIVE_OK) {
ret = 1;
goto cleanup;
}
continue;
} else {
- _alpm_log(PM_LOG_DEBUG, "extracting: %s\n", entryname);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "extracting: %s\n", entryname);
}
}
@@ -321,10 +341,10 @@ int _alpm_unpack(const char *archive, const char *prefix, alpm_list_t *list, int
int readret = archive_read_extract(_archive, entry, 0);
if(readret == ARCHIVE_WARN) {
/* operation succeeded but a non-critical error was encountered */
- _alpm_log(PM_LOG_WARNING, _("warning given when extracting %s (%s)\n"),
+ _alpm_log(handle, ALPM_LOG_WARNING, _("warning given when extracting %s (%s)\n"),
entryname, archive_error_string(_archive));
} else if(readret != ARCHIVE_OK) {
- _alpm_log(PM_LOG_ERROR, _("could not extract %s (%s)\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not extract %s (%s)\n"),
entryname, archive_error_string(_archive));
ret = 1;
goto cleanup;
@@ -339,9 +359,10 @@ cleanup:
umask(oldmask);
archive_read_finish(_archive);
if(restore_cwd && chdir(cwd) != 0) {
- _alpm_log(PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
+ cwd, strerror(errno));
}
- return(ret);
+ return ret;
}
/* does the same thing as 'rm -rf' */
@@ -356,18 +377,18 @@ int _alpm_rmrf(const char *path)
if(_alpm_lstat(path, &st) == 0) {
if(!S_ISDIR(st.st_mode)) {
if(!unlink(path)) {
- return(0);
+ return 0;
} else {
if(errno == ENOENT) {
- return(0);
+ return 0;
} else {
- return(1);
+ return 1;
}
}
} else {
dirp = opendir(path);
if(!dirp) {
- return(1);
+ return 1;
}
for(dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
if(dp->d_ino) {
@@ -382,16 +403,58 @@ int _alpm_rmrf(const char *path)
errflag++;
}
}
- return(errflag);
+ return errflag;
}
- return(0);
+ return 0;
}
-int _alpm_logaction(int usesyslog, FILE *f, const char *fmt, va_list args)
+/**
+ * Determine if there are files in a directory
+ * @param handle the context handle
+ * @param path the full absolute directory path
+ * @param full_count whether to return an exact count of files
+ * @return a file count if full_count is != 0, else >0 if directory has
+ * contents, 0 if no contents, and -1 on error
+ */
+ssize_t _alpm_files_in_directory(alpm_handle_t *handle, const char *path,
+ int full_count)
+{
+ ssize_t files = 0;
+ struct dirent *ent;
+ DIR *dir = opendir(path);
+
+ if(!dir) {
+ if(errno == ENOTDIR) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "%s was not a directory\n", path);
+ } else {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "could not read directory %s\n",
+ path);
+ }
+ return -1;
+ }
+ while((ent = readdir(dir)) != NULL) {
+ const char *name = ent->d_name;
+
+ if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
+ continue;
+ }
+
+ files++;
+
+ if(!full_count) {
+ break;
+ }
+ }
+
+ closedir(dir);
+ return files;
+}
+
+int _alpm_logaction(alpm_handle_t *handle, const char *fmt, va_list args)
{
int ret = 0;
- if(usesyslog) {
+ if(handle->usesyslog) {
/* we can't use a va_list more than once, so we need to copy it
* so we can use the original when calling vfprintf below. */
va_list args_syslog;
@@ -400,7 +463,7 @@ int _alpm_logaction(int usesyslog, FILE *f, const char *fmt, va_list args)
va_end(args_syslog);
}
- if(f) {
+ if(handle->logstream) {
time_t t;
struct tm *tm;
@@ -408,17 +471,17 @@ int _alpm_logaction(int usesyslog, FILE *f, const char *fmt, va_list args)
tm = localtime(&t);
/* Use ISO-8601 date format */
- fprintf(f, "[%04d-%02d-%02d %02d:%02d] ",
+ fprintf(handle->logstream, "[%04d-%02d-%02d %02d:%02d] ",
tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
tm->tm_hour, tm->tm_min);
- ret = vfprintf(f, fmt, args);
- fflush(f);
+ ret = vfprintf(handle->logstream, fmt, args);
+ fflush(handle->logstream);
}
- return(ret);
+ return ret;
}
-int _alpm_run_chroot(const char *root, const char *path, char *const argv[])
+int _alpm_run_chroot(alpm_handle_t *handle, const char *path, char *const argv[])
{
char cwd[PATH_MAX];
pid_t pid;
@@ -426,28 +489,28 @@ int _alpm_run_chroot(const char *root, const char *path, char *const argv[])
int restore_cwd = 0;
int retval = 0;
- ALPM_LOG_FUNC;
-
/* save the cwd so we can restore it later */
if(getcwd(cwd, PATH_MAX) == NULL) {
- _alpm_log(PM_LOG_ERROR, _("could not get current working directory\n"));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not get current working directory\n"));
} else {
restore_cwd = 1;
}
/* just in case our cwd was removed in the upgrade operation */
- if(chdir(root) != 0) {
- _alpm_log(PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), root, strerror(errno));
+ if(chdir(handle->root) != 0) {
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
+ handle->root, strerror(errno));
goto cleanup;
}
- _alpm_log(PM_LOG_DEBUG, "executing \"%s\" under chroot \"%s\"\n", path, root);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "executing \"%s\" under chroot \"%s\"\n",
+ path, handle->root);
/* Flush open fds before fork() to avoid cloning buffers */
fflush(NULL);
if(pipe(pipefd) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not create pipe (%s)\n"), strerror(errno));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not create pipe (%s)\n"), strerror(errno));
retval = 1;
goto cleanup;
}
@@ -455,7 +518,7 @@ int _alpm_run_chroot(const char *root, const char *path, char *const argv[])
/* fork- parent and child each have seperate code blocks below */
pid = fork();
if(pid == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not fork a new process (%s)\n"), strerror(errno));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not fork a new process (%s)\n"), strerror(errno));
retval = 1;
goto cleanup;
}
@@ -470,7 +533,7 @@ int _alpm_run_chroot(const char *root, const char *path, char *const argv[])
close(pipefd[1]);
/* use fprintf instead of _alpm_log to send output through the parent */
- if(chroot(root) != 0) {
+ if(chroot(handle->root) != 0) {
fprintf(stderr, _("could not change the root directory (%s)\n"), strerror(errno));
exit(1);
}
@@ -486,27 +549,27 @@ int _alpm_run_chroot(const char *root, const char *path, char *const argv[])
} else {
/* this code runs for the parent only (wait on the child) */
int status;
- FILE *pipe;
+ FILE *pipe_file;
close(pipefd[1]);
- pipe = fdopen(pipefd[0], "r");
- if(pipe == NULL) {
+ pipe_file = fdopen(pipefd[0], "r");
+ if(pipe_file == NULL) {
close(pipefd[0]);
retval = 1;
} else {
- while(!feof(pipe)) {
+ while(!feof(pipe_file)) {
char line[PATH_MAX];
- if(fgets(line, PATH_MAX, pipe) == NULL)
+ if(fgets(line, PATH_MAX, pipe_file) == NULL)
break;
- alpm_logaction("%s", line);
- EVENT(handle->trans, PM_TRANS_EVT_SCRIPTLET_INFO, line, NULL);
+ alpm_logaction(handle, "%s", line);
+ EVENT(handle->trans, ALPM_TRANS_EVT_SCRIPTLET_INFO, line, NULL);
}
- fclose(pipe);
+ fclose(pipe_file);
}
while(waitpid(pid, &status, 0) == -1) {
if(errno != EINTR) {
- _alpm_log(PM_LOG_ERROR, _("call to waitpid failed (%s)\n"), strerror(errno));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("call to waitpid failed (%s)\n"), strerror(errno));
retval = 1;
goto cleanup;
}
@@ -514,14 +577,14 @@ int _alpm_run_chroot(const char *root, const char *path, char *const argv[])
/* report error from above after the child has exited */
if(retval != 0) {
- _alpm_log(PM_LOG_ERROR, _("could not open pipe (%s)\n"), strerror(errno));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not open pipe (%s)\n"), strerror(errno));
goto cleanup;
}
/* check the return status, make sure it is 0 (success) */
if(WIFEXITED(status)) {
- _alpm_log(PM_LOG_DEBUG, "call to waitpid succeeded\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "call to waitpid succeeded\n");
if(WEXITSTATUS(status) != 0) {
- _alpm_log(PM_LOG_ERROR, _("command failed to execute correctly\n"));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("command failed to execute correctly\n"));
retval = 1;
}
}
@@ -529,42 +592,43 @@ int _alpm_run_chroot(const char *root, const char *path, char *const argv[])
cleanup:
if(restore_cwd && chdir(cwd) != 0) {
- _alpm_log(PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
}
- return(retval);
+ return retval;
}
-int _alpm_ldconfig(const char *root)
+int _alpm_ldconfig(alpm_handle_t *handle)
{
char line[PATH_MAX];
- _alpm_log(PM_LOG_DEBUG, "running ldconfig\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "running ldconfig\n");
- snprintf(line, PATH_MAX, "%setc/ld.so.conf", root);
+ snprintf(line, PATH_MAX, "%setc/ld.so.conf", handle->root);
if(access(line, F_OK) == 0) {
- snprintf(line, PATH_MAX, "%ssbin/ldconfig", root);
+ snprintf(line, PATH_MAX, "%ssbin/ldconfig", handle->root);
if(access(line, X_OK) == 0) {
char *argv[] = { "ldconfig", NULL };
- _alpm_run_chroot(root, "/sbin/ldconfig", argv);
+ _alpm_run_chroot(handle, "/sbin/ldconfig", argv);
}
}
- return(0);
+ return 0;
}
/* Helper function for comparing strings using the
* alpm "compare func" signature */
int _alpm_str_cmp(const void *s1, const void *s2)
{
- return(strcmp(s1, s2));
+ return strcmp(s1, s2);
}
/** Find a filename in a registered alpm cachedir.
+ * @param handle the context handle
* @param filename name of file to find
* @return malloced path of file, NULL if not found
*/
-char *_alpm_filecache_find(const char* filename)
+char *_alpm_filecache_find(alpm_handle_t *handle, const char *filename)
{
char path[PATH_MAX];
char *retpath;
@@ -572,52 +636,56 @@ char *_alpm_filecache_find(const char* filename)
struct stat buf;
/* Loop through the cache dirs until we find a matching file */
- for(i = alpm_option_get_cachedirs(); i; i = alpm_list_next(i)) {
- snprintf(path, PATH_MAX, "%s%s", (char*)alpm_list_getdata(i),
+ for(i = alpm_option_get_cachedirs(handle); i; i = alpm_list_next(i)) {
+ snprintf(path, PATH_MAX, "%s%s", (char *)alpm_list_getdata(i),
filename);
if(stat(path, &buf) == 0 && S_ISREG(buf.st_mode)) {
retpath = strdup(path);
- _alpm_log(PM_LOG_DEBUG, "found cached pkg: %s\n", retpath);
- return(retpath);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "found cached pkg: %s\n", retpath);
+ return retpath;
}
}
/* package wasn't found in any cachedir */
- RET_ERR(PM_ERR_PKG_NOT_FOUND, NULL);
+ return NULL;
}
/** Check the alpm cachedirs for existance and find a writable one.
* If no valid cache directory can be found, use /tmp.
+ * @param handle the context handle
* @return pointer to a writable cache directory.
*/
-const char *_alpm_filecache_setup(void)
+const char *_alpm_filecache_setup(alpm_handle_t *handle)
{
struct stat buf;
alpm_list_t *i, *tmp;
char *cachedir;
/* Loop through the cache dirs until we find a writeable dir */
- for(i = alpm_option_get_cachedirs(); i; i = alpm_list_next(i)) {
+ for(i = alpm_option_get_cachedirs(handle); i; i = alpm_list_next(i)) {
cachedir = alpm_list_getdata(i);
if(stat(cachedir, &buf) != 0) {
/* cache directory does not exist.... try creating it */
- _alpm_log(PM_LOG_WARNING, _("no %s cache exists, creating...\n"),
+ _alpm_log(handle, ALPM_LOG_WARNING, _("no %s cache exists, creating...\n"),
cachedir);
if(_alpm_makepath(cachedir) == 0) {
- _alpm_log(PM_LOG_DEBUG, "using cachedir: %s\n", cachedir);
- return(cachedir);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "using cachedir: %s\n", cachedir);
+ return cachedir;
}
} else if(S_ISDIR(buf.st_mode) && (buf.st_mode & S_IWUSR)) {
- _alpm_log(PM_LOG_DEBUG, "using cachedir: %s\n", cachedir);
- return(cachedir);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "using cachedir: %s\n", cachedir);
+ return cachedir;
+ } else {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "skipping cachedir: %s\n", cachedir);
}
}
/* we didn't find a valid cache directory. use /tmp. */
- tmp = alpm_list_add(NULL, strdup("/tmp/"));
- alpm_option_set_cachedirs(tmp);
- _alpm_log(PM_LOG_DEBUG, "using cachedir: %s", "/tmp/\n");
- _alpm_log(PM_LOG_WARNING, _("couldn't create package cache, using /tmp instead\n"));
- return(alpm_list_getdata(tmp));
+ tmp = alpm_list_add(NULL, "/tmp/");
+ alpm_option_set_cachedirs(handle, tmp);
+ alpm_list_free(tmp);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "using cachedir: %s\n", "/tmp/");
+ _alpm_log(handle, ALPM_LOG_WARNING, _("couldn't create package cache, using /tmp instead\n"));
+ return "/tmp/";
}
/** lstat wrapper that treats /path/dirsymlink/ the same as /path/dirsymlink.
@@ -630,18 +698,19 @@ const char *_alpm_filecache_setup(void)
int _alpm_lstat(const char *path, struct stat *buf)
{
int ret;
- char *newpath = strdup(path);
- size_t len = strlen(newpath);
+ size_t len = strlen(path);
/* strip the trailing slash if one exists */
- if(len != 0 && newpath[len - 1] == '/') {
- newpath[len - 1] = '\0';
+ if(len != 0 && path[len - 1] == '/') {
+ char *newpath = strdup(path);
+ newpath[len - 1] = '\0';
+ ret = lstat(newpath, buf);
+ free(newpath);
+ } else {
+ ret = lstat(path, buf);
}
- ret = lstat(newpath, buf);
-
- FREE(newpath);
- return(ret);
+ return ret;
}
#ifdef HAVE_LIBSSL
@@ -652,11 +721,11 @@ static int md5_file(const char *path, unsigned char output[16])
MD5_CTX ctx;
unsigned char *buf;
- CALLOC(buf, 8192, sizeof(unsigned char), return(1));
+ CALLOC(buf, 8192, sizeof(unsigned char), return 1);
if((f = fopen(path, "rb")) == NULL) {
free(buf);
- return(1);
+ return 1;
}
MD5_Init(&ctx);
@@ -672,11 +741,11 @@ static int md5_file(const char *path, unsigned char output[16])
if(ferror(f) != 0) {
fclose(f);
- return(2);
+ return 2;
}
fclose(f);
- return(0);
+ return 0;
}
#endif
@@ -691,17 +760,15 @@ char SYMEXPORT *alpm_compute_md5sum(const char *filename)
char *md5sum;
int ret, i;
- ALPM_LOG_FUNC;
-
- ASSERT(filename != NULL, return(NULL));
+ ASSERT(filename != NULL, return NULL);
/* allocate 32 chars plus 1 for null */
- md5sum = calloc(33, sizeof(char));
+ CALLOC(md5sum, 33, sizeof(char), return NULL);
/* defined above for OpenSSL, otherwise defined in md5.h */
ret = md5_file(filename, output);
- if (ret > 0) {
- RET_ERR(PM_ERR_NOT_A_FILE, NULL);
+ if(ret > 0) {
+ return NULL;
}
/* Convert the result to something readable */
@@ -709,10 +776,8 @@ char SYMEXPORT *alpm_compute_md5sum(const char *filename)
/* sprintf is acceptable here because we know our output */
sprintf(md5sum +(i * 2), "%02x", output[i]);
}
- md5sum[32] = '\0';
- _alpm_log(PM_LOG_DEBUG, "md5(%s) = %s\n", filename, md5sum);
- return(md5sum);
+ return md5sum;
}
int _alpm_test_md5sum(const char *filepath, const char *md5sum)
@@ -731,7 +796,7 @@ int _alpm_test_md5sum(const char *filepath, const char *md5sum)
}
FREE(md5sum2);
- return(ret);
+ return ret;
}
/* Note: does NOT handle sparse files on purpose for speed. */
@@ -753,13 +818,12 @@ int _alpm_archive_fgets(struct archive *a, struct archive_read_buffer *b)
}
/* zero-copy - this is the entire next block of data. */
- b->ret = archive_read_data_block(a, (void*)&b->block,
+ b->ret = archive_read_data_block(a, (void *)&b->block,
&b->block_size, &offset);
b->block_offset = b->block;
- /* error or end of archive with no data read, cleanup */
- if(b->ret < ARCHIVE_OK ||
- (b->block_size == 0 && b->ret == ARCHIVE_EOF)) {
+ /* error, cleanup */
+ if(b->ret < ARCHIVE_OK) {
goto cleanup;
}
}
@@ -776,20 +840,20 @@ int _alpm_archive_fgets(struct archive *a, struct archive_read_buffer *b)
/* allocate our buffer, or ensure our existing one is big enough */
if(!b->line) {
/* set the initial buffer to the read block_size */
- CALLOC(b->line, b->block_size + 1, sizeof(char),
- RET_ERR(PM_ERR_MEMORY, -1));
+ CALLOC(b->line, b->block_size + 1, sizeof(char), b->ret = -ENOMEM; goto cleanup);
b->line_size = b->block_size + 1;
b->line_offset = b->line;
} else {
size_t needed = (size_t)((b->line_offset - b->line)
+ (i - b->block_offset) + 1);
if(needed > b->max_line_size) {
- RET_ERR(PM_ERR_MEMORY, -1);
+ b->ret = -ERANGE;
+ goto cleanup;
}
if(needed > b->line_size) {
/* need to realloc + copy data to fit total length */
char *new;
- CALLOC(new, needed, sizeof(char), RET_ERR(PM_ERR_MEMORY, -1));
+ CALLOC(new, needed, sizeof(char), b->ret = -ENOMEM; goto cleanup);
memcpy(new, b->line, b->line_size);
b->line_size = needed;
b->line_offset = new + (b->line_offset - b->line);
@@ -804,13 +868,19 @@ int _alpm_archive_fgets(struct archive *a, struct archive_read_buffer *b)
b->line_offset[len] = '\0';
b->block_offset = ++i;
/* this is the main return point; from here you can read b->line */
- return(ARCHIVE_OK);
+ return ARCHIVE_OK;
} else {
/* we've looked through the whole block but no newline, copy it */
size_t len = (size_t)(b->block + b->block_size - b->block_offset);
memcpy(b->line_offset, b->block_offset, len);
b->line_offset += len;
b->block_offset = i;
+ /* there was no new data, return what is left; saved ARCHIVE_EOF will be
+ * returned on next call */
+ if(len == 0) {
+ b->line_offset[0] = '\0';
+ return ARCHIVE_OK;
+ }
}
}
@@ -819,53 +889,60 @@ cleanup:
int ret = b->ret;
FREE(b->line);
memset(b, 0, sizeof(b));
- return(ret);
+ return ret;
}
}
-int _alpm_splitname(const char *target, pmpkg_t *pkg)
+int _alpm_splitname(const char *target, char **name, char **version,
+ unsigned long *name_hash)
{
/* the format of a db entry is as follows:
* package-version-rel/
+ * package-version-rel/desc (we ignore the filename portion)
* package name can contain hyphens, so parse from the back- go back
* two hyphens and we have split the version from the name.
*/
- const char *version, *end;
+ const char *pkgver, *end;
- if(target == NULL || pkg == NULL) {
- return(-1);
+ if(target == NULL) {
+ return -1;
}
- end = target + strlen(target);
- /* remove any trailing '/' */
- while (*(end - 1) == '/') {
- --end;
+ /* remove anything trailing a '/' */
+ end = strchr(target, '/');
+ if(!end) {
+ end = target + strlen(target);
}
/* do the magic parsing- find the beginning of the version string
* by doing two iterations of same loop to lop off two hyphens */
- for(version = end - 1; *version && *version != '-'; version--);
- for(version = version - 1; *version && *version != '-'; version--);
- if(*version != '-' || version == target) {
- return(-1);
+ for(pkgver = end - 1; *pkgver && *pkgver != '-'; pkgver--);
+ for(pkgver = pkgver - 1; *pkgver && *pkgver != '-'; pkgver--);
+ if(*pkgver != '-' || pkgver == target) {
+ return -1;
}
/* copy into fields and return */
- if(pkg->version) {
- FREE(pkg->version);
+ if(version) {
+ if(*version) {
+ FREE(*version);
+ }
+ /* version actually points to the dash, so need to increment 1 and account
+ * for potential end character */
+ STRNDUP(*version, pkgver + 1, end - pkgver - 1, return -1);
}
- /* version actually points to the dash, so need to increment 1 and account
- * for potential end character */
- STRNDUP(pkg->version, version + 1, end - version - 1,
- RET_ERR(PM_ERR_MEMORY, -1));
- if(pkg->name) {
- FREE(pkg->name);
+ if(name) {
+ if(*name) {
+ FREE(*name);
+ }
+ STRNDUP(*name, target, pkgver - target, return -1);
+ if(name_hash) {
+ *name_hash = _alpm_hash_sdbm(*name);
+ }
}
- STRNDUP(pkg->name, target, version - target, RET_ERR(PM_ERR_MEMORY, -1));
- pkg->name_hash = _alpm_hash_sdbm(pkg->name);
- return(0);
+ return 0;
}
/**
@@ -880,13 +957,13 @@ unsigned long _alpm_hash_sdbm(const char *str)
int c;
if(!str) {
- return(hash);
+ return hash;
}
while((c = *str++)) {
hash = c + (hash << 6) + (hash << 16) - hash;
}
- return(hash);
+ return hash;
}
long _alpm_parsedate(const char *line)
@@ -897,9 +974,56 @@ long _alpm_parsedate(const char *line)
setlocale(LC_TIME, "C");
strptime(line, "%a %b %e %H:%M:%S %Y", &tmp_tm);
setlocale(LC_TIME, "");
- return(mktime(&tmp_tm));
+ return mktime(&tmp_tm);
+ }
+ return atol(line);
+}
+
+/**
+ * Wrapper around access() which takes a dir and file argument
+ * separately and generates an appropriate error message.
+ * If dir is NULL file will be treated as the whole path.
+ * @param handle an alpm handle
+ * @param dir directory path ending with and slash
+ * @param file filename
+ * @param amode access mode as described in access()
+ * @return int value returned by access()
+ */
+
+int _alpm_access(alpm_handle_t *handle, const char *dir, const char *file, int amode)
+{
+ size_t len = 0;
+ int ret = 0;
+
+ if (dir) {
+ char *check_path;
+
+ len = strlen(dir) + strlen(file) + 1;
+ CALLOC(check_path, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+ snprintf(check_path, len, "%s%s", dir, file);
+
+ ret = access(check_path, amode);
+ free(check_path);
+ } else {
+ dir = "";
+ ret = access(file, amode);
+ }
+
+ if(ret != 0) {
+ if (amode & R_OK) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, _("\"%s%s\" is not readable: %s\n"), dir, file, strerror(errno));
+ }
+ if (amode & W_OK) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, _("\"%s%s\" is not writable: %s\n"), dir, file, strerror(errno));
+ }
+ if (amode & X_OK) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, _("\"%s%s\" is not executable: %s\n"), dir, file, strerror(errno));
+ }
+ if (amode == F_OK) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, _("\"%s%s\" does not exist: %s\n"), dir, file, strerror(errno));
+ }
}
- return(atol(line));
+ return ret;
}
#ifndef HAVE_STRNDUP
@@ -908,7 +1032,7 @@ static size_t strnlen(const char *s, size_t max)
{
register const char *p;
for(p = s; *p && max--; ++p);
- return(p - s);
+ return (p - s);
}
char *strndup(const char *s, size_t n)
@@ -916,11 +1040,11 @@ char *strndup(const char *s, size_t n)
size_t len = strnlen(s, n);
char *new = (char *) malloc(len + 1);
- if (new == NULL)
+ if(new == NULL)
return NULL;
new[len] = '\0';
- return (char *) memcpy(new, s, len);
+ return (char *)memcpy(new, s, len);
}
#endif
diff --git a/lib/libalpm/util.h b/lib/libalpm/util.h
index c66e9881..9ee63709 100644
--- a/lib/libalpm/util.h
+++ b/lib/libalpm/util.h
@@ -27,7 +27,9 @@
#include "config.h"
#include "alpm_list.h"
-#include "package.h" /* pmpkg_t */
+#include "alpm.h"
+#include "package.h" /* alpm_pkg_t */
+#include "handle.h" /* alpm_handle_t */
#include <stdio.h>
#include <string.h>
@@ -36,6 +38,8 @@
#include <time.h>
#include <sys/stat.h> /* struct stat */
#include <archive.h> /* struct archive */
+#include <math.h> /* fabs */
+#include <float.h> /* DBL_EPSILON */
#ifdef ENABLE_NLS
#include <libintl.h> /* here so it doesn't need to be included elsewhere */
@@ -45,7 +49,7 @@
#define _(s) s
#endif
-#define ALLOC_FAIL(s) do { _alpm_log(PM_LOG_ERROR, _("alloc failure: could not allocate %zd bytes\n"), s); } while(0)
+#define ALLOC_FAIL(s) do { fprintf(stderr, "alloc failure: could not allocate %zd bytes\n", s); } while(0)
#define MALLOC(p, s, action) do { p = calloc(1, s); if(p == NULL) { ALLOC_FAIL(s); action; } } while(0)
#define CALLOC(p, l, s, action) do { p = calloc(l, s); if(p == NULL) { ALLOC_FAIL(s); action; } } while(0)
@@ -57,13 +61,19 @@
#define ASSERT(cond, action) do { if(!(cond)) { action; } } while(0)
-#define RET_ERR_VOID(err) do { pm_errno = (err); \
- _alpm_log(PM_LOG_DEBUG, "returning error %d from %s : %s\n", err, __func__, alpm_strerrorlast()); \
+#define RET_ERR_VOID(handle, err) do { \
+ _alpm_log(handle, ALPM_LOG_DEBUG, "returning error %d from %s : %s\n", err, __func__, alpm_strerror(err)); \
+ (handle)->pm_errno = (err); \
return; } while(0)
-#define RET_ERR(err, ret) do { pm_errno = (err); \
- _alpm_log(PM_LOG_DEBUG, "returning error %d from %s : %s\n", err, __func__, alpm_strerrorlast()); \
- return(ret); } while(0)
+#define RET_ERR(handle, err, ret) do { \
+ _alpm_log(handle, ALPM_LOG_DEBUG, "returning error %d from %s : %s\n", err, __func__, alpm_strerror(err)); \
+ (handle)->pm_errno = (err); \
+ return (ret); } while(0)
+
+#define DOUBLE_EQ(x, y) (fabs((x) - (y)) < DBL_EPSILON)
+
+#define CHECK_HANDLE(handle, action) do { if(!(handle)) { action; } (handle)->pm_errno = 0; } while(0)
/**
* Used as a buffer/state holder for _alpm_archive_fgets().
@@ -85,21 +95,29 @@ int _alpm_makepath(const char *path);
int _alpm_makepath_mode(const char *path, mode_t mode);
int _alpm_copyfile(const char *src, const char *dest);
char *_alpm_strtrim(char *str);
-int _alpm_unpack_single(const char *archive, const char *prefix, const char *fn);
-int _alpm_unpack(const char *archive, const char *prefix, alpm_list_t *list, int breakfirst);
+size_t _alpm_strip_newline(char *str);
+int _alpm_unpack_single(alpm_handle_t *handle, const char *archive,
+ const char *prefix, const char *filename);
+int _alpm_unpack(alpm_handle_t *handle, const char *archive, const char *prefix,
+ alpm_list_t *list, int breakfirst);
int _alpm_rmrf(const char *path);
-int _alpm_logaction(int usesyslog, FILE *f, const char *fmt, va_list args);
-int _alpm_run_chroot(const char *root, const char *path, char *const argv[]);
-int _alpm_ldconfig(const char *root);
+ssize_t _alpm_files_in_directory(alpm_handle_t *handle, const char *path, int full_count);
+int _alpm_logaction(alpm_handle_t *handle, const char *fmt, va_list args);
+int _alpm_run_chroot(alpm_handle_t *handle, const char *path, char *const argv[]);
+int _alpm_ldconfig(alpm_handle_t *handle);
int _alpm_str_cmp(const void *s1, const void *s2);
-char *_alpm_filecache_find(const char *filename);
-const char *_alpm_filecache_setup(void);
+char *_alpm_filecache_find(alpm_handle_t *handle, const char *filename);
+const char *_alpm_filecache_setup(alpm_handle_t *handle);
int _alpm_lstat(const char *path, struct stat *buf);
int _alpm_test_md5sum(const char *filepath, const char *md5sum);
int _alpm_archive_fgets(struct archive *a, struct archive_read_buffer *b);
-int _alpm_splitname(const char *target, pmpkg_t *pkg);
+int _alpm_splitname(const char *target, char **name, char **version,
+ unsigned long *name_hash);
unsigned long _alpm_hash_sdbm(const char *str);
long _alpm_parsedate(const char *line);
+int _alpm_raw_cmp(const char *first, const char *second);
+int _alpm_raw_ncmp(const char *first, const char *second, size_t max);
+int _alpm_access(alpm_handle_t *handle, const char *dir, const char *file, int amode);
#ifndef HAVE_STRSEP
char *strsep(char **, const char *);
@@ -113,6 +131,8 @@ char *strndup(const char *s, size_t n);
#define SYMEXPORT __attribute__((visibility("default")))
#define SYMHIDDEN __attribute__((visibility("internal")))
+#define UNUSED __attribute__((unused))
+
#endif /* _ALPM_UTIL_H */
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/version.c b/lib/libalpm/version.c
index eba66210..9f3a9b71 100644
--- a/lib/libalpm/version.c
+++ b/lib/libalpm/version.c
@@ -93,7 +93,7 @@ static int rpmvercmp(const char *a, const char *b)
int ret = 0;
/* easy comparison to see if versions are identical */
- if(strcmp(a, b) == 0) return(0);
+ if(strcmp(a, b) == 0) return 0;
str1 = strdup(a);
str2 = strdup(b);
@@ -209,7 +209,7 @@ static int rpmvercmp(const char *a, const char *b)
cleanup:
free(str1);
free(str2);
- return(ret);
+ return ret;
}
/** Compare two version strings and determine which one is 'newer'.
@@ -235,15 +235,15 @@ int SYMEXPORT alpm_pkg_vercmp(const char *a, const char *b)
/* ensure our strings are not null */
if(!a && !b) {
- return(0);
+ return 0;
} else if(!a) {
- return(-1);
+ return -1;
} else if(!b) {
- return(1);
+ return 1;
}
/* another quick shortcut- if full version specs are equal */
if(strcmp(a, b) == 0) {
- return(0);
+ return 0;
}
/* Parse both versions into [epoch:]version[-release] triplets. We probably
@@ -266,7 +266,7 @@ int SYMEXPORT alpm_pkg_vercmp(const char *a, const char *b)
free(full1);
free(full2);
- return(ret);
+ return ret;
}
/* vim: set ts=2 sw=2 noet: */