summaryrefslogtreecommitdiffstats
path: root/lib/libalpm/package.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/libalpm/package.c')
-rw-r--r--lib/libalpm/package.c1299
1 files changed, 711 insertions, 588 deletions
diff --git a/lib/libalpm/package.c b/lib/libalpm/package.c
index 74adf5cd..172456d6 100644
--- a/lib/libalpm/package.c
+++ b/lib/libalpm/package.c
@@ -5,7 +5,7 @@
* Copyright (c) 2005 by Aurelien Foret <orelien@chez.com>
* Copyright (c) 2005, 2006 by Christian Hamar <krics@linuxforum.hu>
* Copyright (c) 2005, 2006 by Miklos Vajna <vmiklos@frugalware.org>
- *
+ *
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
@@ -18,7 +18,7 @@
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
* USA.
*/
@@ -28,12 +28,16 @@
#include <stdlib.h>
#include <limits.h>
#include <string.h>
-#include <libintl.h>
-#include <locale.h>
+#include <ctype.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
+#include <locale.h> /* setlocale */
+
+/* libarchive */
+#include <archive.h>
+#include <archive_entry.h>
/* libalpm */
#include "package.h"
@@ -43,554 +47,113 @@
#include "error.h"
#include "db.h"
#include "cache.h"
-#include "provide.h"
+#include "delta.h"
#include "handle.h"
-#include "versioncmp.h"
-#include "alpm.h"
-
-pmpkg_t *_alpm_pkg_new(const char *name, const char *version)
-{
- pmpkg_t* pkg;
-
- ALPM_LOG_FUNC;
-
- if((pkg = calloc(1,sizeof(pmpkg_t))) == NULL) {
- RET_ERR(PM_ERR_MEMORY, NULL);
- }
-
- if(name && name[0] != 0) {
- STRNCPY(pkg->name, name, PKG_NAME_LEN);
- } else {
- pkg->name[0] = '\0';
- }
- if(version && version[0] != 0) {
- STRNCPY(pkg->version, version, PKG_VERSION_LEN);
- } else {
- pkg->version[0] = '\0';
- }
-
- return(pkg);
-}
-
-pmpkg_t *_alpm_pkg_dup(pmpkg_t *pkg)
-{
- pmpkg_t* newpkg;
-
- ALPM_LOG_FUNC;
-
- if((newpkg = calloc(1, sizeof(pmpkg_t))) == NULL) {
- _alpm_log(PM_LOG_ERROR, _("malloc failure: could not allocate %d bytes"), sizeof(pmpkg_t));
- RET_ERR(PM_ERR_MEMORY, NULL);
- }
-
- memcpy(newpkg, pkg, sizeof(pmpkg_t));
- newpkg->licenses = alpm_list_strdup(alpm_pkg_get_licenses(pkg));
- /*newpkg->desc_localized = alpm_list_strdup(pkg->desc_localized);*/
- newpkg->requiredby = alpm_list_strdup(alpm_pkg_get_requiredby(pkg));
- newpkg->conflicts = alpm_list_strdup(alpm_pkg_get_conflicts(pkg));
- newpkg->files = alpm_list_strdup(alpm_pkg_get_files(pkg));
- newpkg->backup = alpm_list_strdup(alpm_pkg_get_backup(pkg));
- newpkg->depends = alpm_list_strdup(alpm_pkg_get_depends(pkg));
- newpkg->removes = alpm_list_strdup(alpm_pkg_get_removes(pkg));
- newpkg->groups = alpm_list_strdup(alpm_pkg_get_groups(pkg));
- newpkg->provides = alpm_list_strdup(alpm_pkg_get_provides(pkg));
- newpkg->replaces = alpm_list_strdup(alpm_pkg_get_replaces(pkg));
- /* internal */
- newpkg->data = (newpkg->origin == PKG_FROM_FILE) ? strdup(pkg->data) : pkg->data;
-
- return(newpkg);
-}
-
-void _alpm_pkg_free(void *data)
-{
- pmpkg_t *pkg = data;
-
- ALPM_LOG_FUNC;
-
- if(pkg == NULL) {
- return;
- }
-
- FREELIST(pkg->licenses);
- /*FREELIST(pkg->desc_localized);*/
- FREELIST(pkg->files);
- FREELIST(pkg->backup);
- FREELIST(pkg->depends);
- FREELIST(pkg->removes);
- FREELIST(pkg->conflicts);
- FREELIST(pkg->requiredby);
- FREELIST(pkg->groups);
- FREELIST(pkg->provides);
- FREELIST(pkg->replaces);
- if(pkg->origin == PKG_FROM_FILE) {
- FREE(pkg->data);
- }
- FREE(pkg);
-
- return;
-}
-
-/* Is pkgB an upgrade for pkgA ? */
-int alpm_pkg_compare_versions(pmpkg_t *local_pkg, pmpkg_t *pkg)
-{
- int cmp = 0;
-
- ALPM_LOG_FUNC;
-
- if(pkg->origin == PKG_FROM_CACHE) {
- /* ensure we have the /desc file, which contains the 'force' option */
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
- }
-
- if(alpm_list_find_str(handle->ignorepkg, alpm_pkg_get_name(pkg))) {
- /* package should be ignored (IgnorePkg) */
- _alpm_log(PM_LOG_WARNING, _("%s-%s: ignoring package upgrade (%s)"),
- alpm_pkg_get_name(local_pkg), alpm_pkg_get_version(local_pkg),
- alpm_pkg_get_version(pkg));
- return(0);
- }
-
- /* compare versions and see if we need to upgrade */
- cmp = _alpm_versioncmp(alpm_pkg_get_version(pkg), alpm_pkg_get_version(local_pkg));
-
- if(cmp != 0 && pkg->force) {
- cmp = 1;
- _alpm_log(PM_LOG_WARNING, _("%s: forcing upgrade to version %s"),
- alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
- } else if(cmp < 0) {
- /* local version is newer */
- pmdb_t *db = pkg->data;
- _alpm_log(PM_LOG_WARNING, _("%s: local (%s) is newer than %s (%s)"),
- alpm_pkg_get_name(local_pkg), alpm_pkg_get_version(local_pkg),
- alpm_db_get_name(db), alpm_pkg_get_version(pkg));
- cmp = 0;
- } else if(cmp > 0) {
- /* we have an upgrade, make sure we should actually do it */
- if(_alpm_pkg_istoonew(pkg)) {
- /* package too new (UpgradeDelay) */
- _alpm_log(PM_LOG_WARNING, _("%s-%s: delaying upgrade of package (%s)"),
- alpm_pkg_get_name(local_pkg), alpm_pkg_get_version(local_pkg),
- alpm_pkg_get_version(pkg));
- cmp = 0;
- }
- }
+#include "deps.h"
- return(cmp);
-}
-
-/* Helper function for comparing packages
+/** \addtogroup alpm_packages Package Functions
+ * @brief Functions to manipulate libalpm packages
+ * @{
*/
-int _alpm_pkg_cmp(const void *p1, const void *p2)
-{
- pmpkg_t *pk1 = (pmpkg_t *)p1;
- pmpkg_t *pk2 = (pmpkg_t *)p2;
-
- return(strcmp(alpm_pkg_get_name(pk1), alpm_pkg_get_name(pk2)));
-}
-/* Parses the package description file for the current package
- * TODO: this should ALL be in a backend interface (be_files), we should
- * be dealing with the abstracted concepts only in this file
- * Returns: 0 on success, 1 on error
- *
+/** Create a package from a file.
+ * @param filename location of the package tarball
+ * @param full whether to stop the load after metadata is read or continue
+ * through the full archive
+ * @param pkg address of the package pointer
+ * @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
-static int parse_descfile(const char *descfile, pmpkg_t *info)
+int SYMEXPORT alpm_pkg_load(const char *filename, unsigned short full,
+ pmpkg_t **pkg)
{
- FILE* fp = NULL;
- char line[PATH_MAX];
- char *ptr = NULL;
- char *key = NULL;
- int linenum = 0;
+ _alpm_log(PM_LOG_FUNCTION, "enter alpm_pkg_load\n");
- 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));
- if((fp = fopen(descfile, "r")) == NULL) {
- _alpm_log(PM_LOG_ERROR, _("could not open file %s: %s"), descfile, strerror(errno));
+ *pkg = _alpm_pkg_load(filename, full);
+ if(*pkg == NULL) {
+ /* pm_errno is set by pkg_load */
return(-1);
}
- while(!feof(fp)) {
- fgets(line, PATH_MAX, fp);
- linenum++;
- _alpm_strtrim(line);
- if(strlen(line) == 0 || line[0] == '#') {
- continue;
- }
- ptr = line;
- key = strsep(&ptr, "=");
- if(key == NULL || ptr == NULL) {
- _alpm_log(PM_LOG_DEBUG, _("%s: syntax error in description file line %d"),
- info->name[0] != '\0' ? info->name : "error", linenum);
- } else {
- _alpm_strtrim(key);
- key = _alpm_strtoupper(key);
- _alpm_strtrim(ptr);
- if(!strcmp(key, "PKGNAME")) {
- STRNCPY(info->name, ptr, sizeof(info->name));
- } else if(!strcmp(key, "PKGVER")) {
- STRNCPY(info->version, ptr, sizeof(info->version));
- } else if(!strcmp(key, "PKGDESC")) {
- /*
- char *lang_tmp;
- info->desc_localized = alpm_list_add(info->desc_localized, strdup(ptr));
- if((lang_tmp = (char *)malloc(strlen(setlocale(LC_ALL, "")))) == NULL) {
- RET_ERR(PM_ERR_MEMORY, -1);
- }
- STRNCPY(lang_tmp, setlocale(LC_ALL, ""), strlen(setlocale(LC_ALL, "")));
- if(info->desc_localized && !info->desc_localized->next) {
- */
- STRNCPY(info->desc, ptr, sizeof(info->desc));
- /*
- } else if (ptr && !strncmp(ptr, lang_tmp, strlen(lang_tmp))) {
- STRNCPY(info->desc, ptr+strlen(lang_tmp)+1, sizeof(info->desc));
- }
- FREE(lang_tmp);
- */
- } else if(!strcmp(key, "GROUP")) {
- info->groups = alpm_list_add(info->groups, strdup(ptr));
- } else if(!strcmp(key, "URL")) {
- STRNCPY(info->url, ptr, sizeof(info->url));
- } else if(!strcmp(key, "LICENSE")) {
- info->licenses = alpm_list_add(info->licenses, strdup(ptr));
- } else if(!strcmp(key, "BUILDDATE")) {
- STRNCPY(info->builddate, ptr, sizeof(info->builddate));
- } else if(!strcmp(key, "BUILDTYPE")) {
- STRNCPY(info->buildtype, ptr, sizeof(info->buildtype));
- } else if(!strcmp(key, "INSTALLDATE")) {
- STRNCPY(info->installdate, ptr, sizeof(info->installdate));
- } else if(!strcmp(key, "PACKAGER")) {
- STRNCPY(info->packager, ptr, sizeof(info->packager));
- } else if(!strcmp(key, "ARCH")) {
- STRNCPY(info->arch, ptr, sizeof(info->arch));
- } else if(!strcmp(key, "SIZE")) {
- /* size in the raw package is uncompressed (installed) size */
- info->isize = atol(ptr);
- } else if(!strcmp(key, "DEPEND")) {
- info->depends = alpm_list_add(info->depends, strdup(ptr));
- } else if(!strcmp(key, "REMOVE")) {
- info->removes = alpm_list_add(info->removes, strdup(ptr));
- } else if(!strcmp(key, "CONFLICT")) {
- info->conflicts = alpm_list_add(info->conflicts, strdup(ptr));
- } else if(!strcmp(key, "REPLACES")) {
- info->replaces = alpm_list_add(info->replaces, strdup(ptr));
- } else if(!strcmp(key, "PROVIDES")) {
- info->provides = alpm_list_add(info->provides, strdup(ptr));
- } else if(!strcmp(key, "BACKUP")) {
- info->backup = alpm_list_add(info->backup, strdup(ptr));
- } else {
- _alpm_log(PM_LOG_DEBUG, _("%s: syntax error in description file line %d"),
- info->name[0] != '\0' ? info->name : "error", linenum);
- }
- }
- line[0] = '\0';
- }
- fclose(fp);
- unlink(descfile);
-
return(0);
}
-pmpkg_t *_alpm_pkg_load(const char *pkgfile)
+/** Free a package.
+ * @param pkg package pointer to free
+ * @return 0 on success, -1 on error (pm_errno is set accordingly)
+ */
+int SYMEXPORT alpm_pkg_free(pmpkg_t *pkg)
{
- char *expath;
- int ret = ARCHIVE_OK;
- int config = 0;
- int filelist = 0;
- int scriptcheck = 0;
- struct archive *archive;
- struct archive_entry *entry;
- pmpkg_t *info = NULL;
- char *descfile = NULL;
- int fd = -1;
- alpm_list_t *all_files = NULL;
- struct stat st;
-
- ALPM_LOG_FUNC;
-
- if(pkgfile == NULL || strlen(pkgfile) == 0) {
- RET_ERR(PM_ERR_WRONG_ARGS, NULL);
- }
-
- if((archive = archive_read_new()) == NULL) {
- RET_ERR(PM_ERR_LIBARCHIVE_ERROR, NULL);
- }
-
- archive_read_support_compression_all(archive);
- archive_read_support_format_all(archive);
-
- if (archive_read_open_file(archive, pkgfile, ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
- RET_ERR(PM_ERR_PKG_OPEN, NULL);
- }
-
- info = _alpm_pkg_new(NULL, NULL);
- if(info == NULL) {
- archive_read_finish(archive);
- RET_ERR(PM_ERR_MEMORY, NULL);
- }
-
- if(stat(pkgfile, &st) == 0) {
- info->size = st.st_size;
- }
+ _alpm_log(PM_LOG_FUNCTION, "enter alpm_pkg_free\n");
- /* TODO there is no reason to make temp files to read
- * from a libarchive archive, it can be done by reading
- * directly from the archive
- * See: archive_read_data_into_buffer
- * requires changes 'parse_descfile' as well
- * */
+ ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
- /* Read through the entire archive for metadata. We will continue reading
- * even if all metadata is found, to verify the integrity of the archive in
- * full */
- while((ret = archive_read_next_header (archive, &entry)) == ARCHIVE_OK) {
- const char *entry_name = archive_entry_pathname(entry);
-
- if(strcmp(entry_name, ".PKGINFO") == 0) {
- /* extract this file into /tmp. it has info for us */
- descfile = strdup("/tmp/alpm_XXXXXX");
- fd = mkstemp(descfile);
- archive_read_data_into_fd (archive, fd);
- /* parse the info file */
- if(parse_descfile(descfile, info) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not parse the package description file"));
- goto pkg_invalid;
- }
- if(!strlen(info->name)) {
- _alpm_log(PM_LOG_ERROR, _("missing package name in %s"), pkgfile);
- goto pkg_invalid;
- }
- if(!strlen(info->version)) {
- _alpm_log(PM_LOG_ERROR, _("missing package version in %s"), pkgfile);
- goto pkg_invalid;
- }
- config = 1;
- unlink(descfile);
- FREE(descfile);
- close(fd);
- continue;
- } else if(strcmp(entry_name, ".INSTALL") == 0) {
- info->scriptlet = 1;
- scriptcheck = 1;
- } else if(strcmp(entry_name, ".FILELIST") == 0) {
- /* Build info->files from the filelist */
- FILE *fp;
- char *fn;
- char *str;
- int fd;
-
- if((str = (char *)malloc(PATH_MAX)) == NULL) {
- RET_ERR(PM_ERR_MEMORY, (pmpkg_t *)-1);
- }
- fn = strdup("/tmp/alpm_XXXXXX");
- fd = mkstemp(fn);
- archive_read_data_into_fd(archive,fd);
- fp = fopen(fn, "r");
- while(!feof(fp)) {
- if(fgets(str, PATH_MAX, fp) == NULL) {
- continue;
- }
- _alpm_strtrim(str);
- info->files = alpm_list_add(info->files, strdup(str));
- }
- FREE(str);
- fclose(fp);
- if(unlink(fn)) {
- _alpm_log(PM_LOG_WARNING, _("could not remove tempfile %s"), fn);
- }
- FREE(fn);
- close(fd);
- filelist = 1;
- continue;
- } else {
- scriptcheck = 1;
- /* Keep track of all files so we can generate a filelist later if missing */
- all_files = alpm_list_add(all_files, strdup(entry_name));
- }
-
- if(archive_read_data_skip(archive)) {
- _alpm_log(PM_LOG_ERROR, _("error while reading package: %s"), archive_error_string(archive));
- pm_errno = PM_ERR_LIBARCHIVE_ERROR;
- goto error;
- }
- expath = NULL;
- }
- if(ret != ARCHIVE_EOF) { /* An error occured */
- _alpm_log(PM_LOG_ERROR, _("error while reading package: %s"), archive_error_string(archive));
- pm_errno = PM_ERR_LIBARCHIVE_ERROR;
- goto error;
- }
-
- if(!config) {
- _alpm_log(PM_LOG_ERROR, _("missing package metadata"), pkgfile);
- goto error;
- }
-
- archive_read_finish(archive);
-
- if(!filelist) {
- _alpm_log(PM_LOG_ERROR, _("missing package filelist in %s, generating one"), pkgfile);
- info->files = all_files;
- } else {
- alpm_list_free_inner(all_files, free);
- alpm_list_free(all_files);
+ /* Only free packages loaded in user space */
+ if(pkg->origin != PKG_FROM_CACHE) {
+ _alpm_pkg_free(pkg);
}
- /* this is IMPORTANT - "checking for conflicts" requires a sorted list, so we
- * ensure that here */
- info->files = alpm_list_msort(info->files, alpm_list_count(info->files), _alpm_str_cmp);
-
- /* internal */
- info->origin = PKG_FROM_FILE;
- info->data = strdup(pkgfile);
- info->infolevel = 0xFF;
-
- return(info);
-
-pkg_invalid:
- pm_errno = PM_ERR_PKG_INVALID;
- if(descfile) {
- unlink(descfile);
- FREE(descfile);
- }
- if(fd != -1) {
- close(fd);
- }
-error:
- FREEPKG(info);
- archive_read_finish(archive);
-
- return(NULL);
+ return(0);
}
-/* Test for existence of a package in a alpm_list_t*
- * of pmpkg_t*
+/** 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)
*/
-pmpkg_t *_alpm_pkg_find(const char *needle, alpm_list_t *haystack)
+int SYMEXPORT alpm_pkg_checkmd5sum(pmpkg_t *pkg)
{
- alpm_list_t *lp;
+ char *fpath;
+ char *md5sum = NULL;
+ int retval = 0;
ALPM_LOG_FUNC;
- if(needle == NULL || haystack == NULL) {
- return(NULL);
- }
+ ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
+ /* We only inspect packages from sync repositories */
+ ASSERT(pkg->origin == PKG_FROM_CACHE, RET_ERR(PM_ERR_PKG_INVALID, -1));
+ ASSERT(pkg->origin_data.db != handle->db_local, RET_ERR(PM_ERR_PKG_INVALID, -1));
- for(lp = haystack; lp; lp = lp->next) {
- pmpkg_t *info = lp->data;
+ fpath = _alpm_filecache_find(alpm_pkg_get_filename(pkg));
+ md5sum = alpm_get_md5sum(fpath);
- if(info && strcmp(alpm_pkg_get_name(info), needle) == 0) {
- return(info);
- }
- }
- return(NULL);
-}
-
-int _alpm_pkg_splitname(const char *target, char *name, char *version, int witharch)
-{
- char tmp[PKG_FULLNAME_LEN+7];
- const char *t;
- char *p, *q;
-
- ALPM_LOG_FUNC;
-
- if(target == NULL) {
- return(-1);
- }
-
- /* trim path name (if any) */
- if((t = strrchr(target, '/')) == NULL) {
- t = target;
+ if(md5sum == NULL) {
+ _alpm_log(PM_LOG_ERROR, _("could not get md5sum for package %s-%s\n"),
+ alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
+ pm_errno = PM_ERR_NOT_A_FILE;
+ retval = -1;
} else {
- t++;
- }
- STRNCPY(tmp, t, PKG_FULLNAME_LEN+7);
- /* trim file extension (if any) */
- if((p = strstr(tmp, PM_EXT_PKG))) {
- *p = '\0';
- }
-
- if(witharch) {
- /* trim architecture */
- if((p = alpm_pkg_name_hasarch(tmp))) {
- *p = 0;
+ if(strcmp(md5sum, alpm_pkg_get_md5sum(pkg)) == 0) {
+ _alpm_log(PM_LOG_DEBUG, "md5sums for package %s-%s match\n",
+ alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
+ } else {
+ _alpm_log(PM_LOG_ERROR, _("md5sums do not match for package %s-%s\n"),
+ alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
+ pm_errno = PM_ERR_PKG_INVALID;
+ retval = -1;
}
}
- p = tmp + strlen(tmp);
+ FREE(fpath);
+ FREE(md5sum);
- for(q = --p; *q && *q != '-'; q--);
- if(*q != '-' || q == tmp) {
- return(-1);
- }
- for(p = --q; *p && *p != '-'; p--);
- if(*p != '-' || p == tmp) {
- return(-1);
- }
- if(version) {
- STRNCPY(version, p+1, PKG_VERSION_LEN);
- }
- *p = '\0';
-
- if(name) {
- STRNCPY(name, tmp, PKG_NAME_LEN);
- }
-
- return(0);
+ return(retval);
}
-
-void _alpm_pkg_update_requiredby(pmpkg_t *pkg)
+/** Compare versions.
+ * @param ver1 first version
+ * @param ver2 secont version
+ * @return postive, 0 or negative if ver1 is less, equal or more
+ * than ver2, respectively.
+ */
+int SYMEXPORT alpm_pkg_vercmp(const char *ver1, const char *ver2)
{
- alpm_list_t *i, *j, *k;
- const char *pkgname = alpm_pkg_get_name(pkg);
-
- pmdb_t *localdb = alpm_option_get_localdb();
- for(i = _alpm_db_get_pkgcache(localdb); i; i = i->next) {
- if(!i->data) {
- continue;
- }
- pmpkg_t *cachepkg = i->data;
- const char *cachepkgname = alpm_pkg_get_name(cachepkg);
-
- for(j = alpm_pkg_get_depends(cachepkg); j; j = j->next) {
- pmdepend_t *dep;
- if(!j->data) {
- continue;
- }
- dep = alpm_splitdep(j->data);
- if(dep == NULL) {
- continue;
- }
-
- /* check the actual package itself */
- if(strcmp(dep->name, pkgname) == 0) {
- alpm_list_t *reqs = alpm_pkg_get_requiredby(pkg);
-
- if(!alpm_list_find_str(reqs, cachepkgname)) {
- _alpm_log(PM_LOG_DEBUG, _("adding '%s' in requiredby field for '%s'"),
- cachepkgname, pkg->name);
- reqs = alpm_list_add(reqs, strdup(cachepkgname));
- pkg->requiredby = reqs;
- }
- }
+ ALPM_LOG_FUNC;
- /* check for provisions as well */
- for(k = alpm_pkg_get_provides(pkg); k; k = k->next) {
- const char *provname = k->data;
- if(strcmp(dep->name, provname) == 0) {
- alpm_list_t *reqs = alpm_pkg_get_requiredby(pkg);
-
- if(!alpm_list_find_str(reqs, cachepkgname)) {
- _alpm_log(PM_LOG_DEBUG, _("adding '%s' in requiredby field for '%s' (provides: %s)"),
- cachepkgname, pkgname, provname);
- reqs = alpm_list_add(reqs, strdup(cachepkgname));
- pkg->requiredby = reqs;
- }
- }
- }
- free(dep);
- }
- }
+ return(_alpm_versioncmp(ver1, ver2));
}
const char SYMEXPORT *alpm_pkg_get_filename(pmpkg_t *pkg)
@@ -604,13 +167,13 @@ const char SYMEXPORT *alpm_pkg_get_filename(pmpkg_t *pkg)
if(!strlen(pkg->filename)) {
/* construct the file name, it's not in the desc file */
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
if(pkg->arch && strlen(pkg->arch) > 0) {
- snprintf(pkg->filename, PKG_FILENAME_LEN, "%s-%s-%s" PM_EXT_PKG,
+ snprintf(pkg->filename, PKG_FILENAME_LEN, "%s-%s-%s" PKGEXT,
pkg->name, pkg->version, pkg->arch);
} else {
- snprintf(pkg->filename, PKG_FILENAME_LEN, "%s-%s" PM_EXT_PKG,
+ snprintf(pkg->filename, PKG_FILENAME_LEN, "%s-%s" PKGEXT,
pkg->name, pkg->version);
}
}
@@ -627,7 +190,7 @@ const char SYMEXPORT *alpm_pkg_get_name(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_BASE)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_BASE);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_BASE);
}
return pkg->name;
}
@@ -641,7 +204,7 @@ const char SYMEXPORT *alpm_pkg_get_version(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_BASE)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_BASE);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_BASE);
}
return pkg->version;
}
@@ -655,7 +218,7 @@ const char SYMEXPORT *alpm_pkg_get_desc(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
return pkg->desc;
}
@@ -669,49 +232,35 @@ const char SYMEXPORT *alpm_pkg_get_url(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
return pkg->url;
}
-const char SYMEXPORT *alpm_pkg_get_builddate(pmpkg_t *pkg)
+time_t SYMEXPORT alpm_pkg_get_builddate(pmpkg_t *pkg)
{
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(pkg != NULL, return(NULL));
+ ASSERT(handle != NULL, return(0));
+ ASSERT(pkg != NULL, return(0));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
return pkg->builddate;
}
-const char SYMEXPORT *alpm_pkg_get_buildtype(pmpkg_t *pkg)
+time_t SYMEXPORT alpm_pkg_get_installdate(pmpkg_t *pkg)
{
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(pkg != NULL, return(NULL));
+ ASSERT(handle != NULL, return(0));
+ ASSERT(pkg != NULL, return(0));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
- }
- return pkg->buildtype;
-}
-
-const char SYMEXPORT *alpm_pkg_get_installdate(pmpkg_t *pkg)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(pkg != NULL, return(NULL));
-
- if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
return pkg->installdate;
}
@@ -725,7 +274,7 @@ const char SYMEXPORT *alpm_pkg_get_packager(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
return pkg->packager;
}
@@ -739,25 +288,11 @@ const char SYMEXPORT *alpm_pkg_get_md5sum(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
return pkg->md5sum;
}
-const char SYMEXPORT *alpm_pkg_get_sha1sum(pmpkg_t *pkg)
-{
- ALPM_LOG_FUNC;
-
- /* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(pkg != NULL, return(NULL));
-
- if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
- }
- return pkg->sha1sum;
-}
-
const char SYMEXPORT *alpm_pkg_get_arch(pmpkg_t *pkg)
{
ALPM_LOG_FUNC;
@@ -767,7 +302,7 @@ const char SYMEXPORT *alpm_pkg_get_arch(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
return pkg->arch;
}
@@ -781,7 +316,7 @@ unsigned long SYMEXPORT alpm_pkg_get_size(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(-1));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
return pkg->size;
}
@@ -795,7 +330,7 @@ unsigned long SYMEXPORT alpm_pkg_get_isize(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(-1));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
return pkg->isize;
}
@@ -809,7 +344,7 @@ pmpkgreason_t SYMEXPORT alpm_pkg_get_reason(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(-1));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
return pkg->reason;
}
@@ -823,7 +358,7 @@ alpm_list_t SYMEXPORT *alpm_pkg_get_licenses(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
return pkg->licenses;
}
@@ -837,12 +372,11 @@ alpm_list_t SYMEXPORT *alpm_pkg_get_groups(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
return pkg->groups;
}
-/* depends */
alpm_list_t SYMEXPORT *alpm_pkg_get_depends(pmpkg_t *pkg)
{
ALPM_LOG_FUNC;
@@ -852,12 +386,12 @@ alpm_list_t SYMEXPORT *alpm_pkg_get_depends(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DEPENDS)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DEPENDS);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DEPENDS);
}
return pkg->depends;
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_removes(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_get_optdepends(pmpkg_t *pkg)
{
ALPM_LOG_FUNC;
@@ -866,12 +400,12 @@ alpm_list_t SYMEXPORT *alpm_pkg_get_removes(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DEPENDS)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DEPENDS);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DEPENDS);
}
- return pkg->removes;
+ return pkg->optdepends;
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_requiredby(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_get_conflicts(pmpkg_t *pkg)
{
ALPM_LOG_FUNC;
@@ -880,12 +414,12 @@ alpm_list_t SYMEXPORT *alpm_pkg_get_requiredby(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DEPENDS)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DEPENDS);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DEPENDS);
}
- return pkg->requiredby;
+ return pkg->conflicts;
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_conflicts(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_get_provides(pmpkg_t *pkg)
{
ALPM_LOG_FUNC;
@@ -894,12 +428,12 @@ alpm_list_t SYMEXPORT *alpm_pkg_get_conflicts(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DEPENDS)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DEPENDS);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DEPENDS);
}
- return pkg->conflicts;
+ return pkg->provides;
}
-alpm_list_t SYMEXPORT *alpm_pkg_get_provides(pmpkg_t *pkg)
+alpm_list_t SYMEXPORT *alpm_pkg_get_deltas(pmpkg_t *pkg)
{
ALPM_LOG_FUNC;
@@ -907,10 +441,10 @@ alpm_list_t SYMEXPORT *alpm_pkg_get_provides(pmpkg_t *pkg)
ASSERT(handle != NULL, return(NULL));
ASSERT(pkg != NULL, return(NULL));
- if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DEPENDS)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DEPENDS);
+ if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DELTAS)) {
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DELTAS);
}
- return pkg->provides;
+ return pkg->deltas;
}
alpm_list_t SYMEXPORT *alpm_pkg_get_replaces(pmpkg_t *pkg)
@@ -922,7 +456,7 @@ alpm_list_t SYMEXPORT *alpm_pkg_get_replaces(pmpkg_t *pkg)
ASSERT(pkg != NULL, return(NULL));
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
}
return pkg->replaces;
}
@@ -935,9 +469,9 @@ alpm_list_t SYMEXPORT *alpm_pkg_get_files(pmpkg_t *pkg)
ASSERT(handle != NULL, return(NULL));
ASSERT(pkg != NULL, return(NULL));
- if(pkg->origin == PKG_FROM_CACHE && pkg->data == handle->db_local
+ if(pkg->origin == PKG_FROM_CACHE && pkg->origin_data.db == handle->db_local
&& !(pkg->infolevel & INFRQ_FILES)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_FILES);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_FILES);
}
return pkg->files;
}
@@ -950,9 +484,9 @@ alpm_list_t SYMEXPORT *alpm_pkg_get_backup(pmpkg_t *pkg)
ASSERT(handle != NULL, return(NULL));
ASSERT(pkg != NULL, return(NULL));
- if(pkg->origin == PKG_FROM_CACHE && pkg->data == handle->db_local
+ if(pkg->origin == PKG_FROM_CACHE && pkg->origin_data.db == handle->db_local
&& !(pkg->infolevel & INFRQ_FILES)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_FILES);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_FILES);
}
return pkg->backup;
}
@@ -965,13 +499,572 @@ unsigned short SYMEXPORT alpm_pkg_has_scriptlet(pmpkg_t *pkg)
ASSERT(handle != NULL, return(-1));
ASSERT(pkg != NULL, return(-1));
- if(pkg->origin == PKG_FROM_CACHE && pkg->data == handle->db_local
+ if(pkg->origin == PKG_FROM_CACHE && pkg->origin_data.db == handle->db_local
&& !(pkg->infolevel & INFRQ_SCRIPTLET)) {
- _alpm_db_read(pkg->data, pkg, INFRQ_SCRIPTLET);
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_SCRIPTLET);
}
return pkg->scriptlet;
}
+/**
+ * @brief Compute the packages requiring a given package.
+ * @param pkg a package
+ * @return the list of packages requiring pkg
+ *
+ * A depends on B through n depends <=> A listed in B's requiredby n times
+ * n == 0 or 1 in almost all cases */
+alpm_list_t SYMEXPORT *alpm_pkg_compute_requiredby(pmpkg_t *pkg)
+{
+ const alpm_list_t *i, *j;
+ alpm_list_t *reqs = NULL;
+
+ pmdb_t *localdb = alpm_option_get_localdb();
+ for(i = _alpm_db_get_pkgcache(localdb); i; i = i->next) {
+ if(!i->data) {
+ continue;
+ }
+ pmpkg_t *cachepkg = i->data;
+ const char *cachepkgname = alpm_pkg_get_name(cachepkg);
+
+ for(j = alpm_pkg_get_depends(cachepkg); j; j = j->next) {
+ pmdepend_t *dep = j->data;
+
+ if(alpm_depcmp(pkg, dep)) {
+ _alpm_log(PM_LOG_DEBUG, "adding '%s' in requiredby field for '%s'\n",
+ cachepkgname, pkg->name);
+ reqs = alpm_list_add(reqs, strdup(cachepkgname));
+ }
+ }
+ }
+ return(reqs);
+}
+
+/** @} */
+
+/* this function was taken from rpm 4.0.4 and rewritten */
+int _alpm_versioncmp(const char *a, const char *b)
+{
+ char str1[64], str2[64];
+ char *ptr1, *ptr2;
+ char *one, *two;
+ char *rel1 = NULL, *rel2 = NULL;
+ char oldch1, oldch2;
+ int is1num, is2num;
+ int rc;
+
+ ALPM_LOG_FUNC;
+
+ if(!strcmp(a,b)) {
+ return(0);
+ }
+
+ strncpy(str1, a, 64);
+ str1[63] = 0;
+ strncpy(str2, b, 64);
+ str2[63] = 0;
+
+ /* lose the release number */
+ for(one = str1; *one && *one != '-'; one++);
+ if(one) {
+ *one = '\0';
+ rel1 = ++one;
+ }
+ for(two = str2; *two && *two != '-'; two++);
+ if(two) {
+ *two = '\0';
+ rel2 = ++two;
+ }
+
+ one = str1;
+ two = str2;
+
+ while(*one || *two) {
+ while(*one && !isalnum((int)*one)) one++;
+ while(*two && !isalnum((int)*two)) two++;
+
+ ptr1 = one;
+ ptr2 = two;
+
+ /* find the next segment for each string */
+ if(isdigit((int)*ptr1)) {
+ is1num = 1;
+ while(*ptr1 && isdigit((int)*ptr1)) ptr1++;
+ } else {
+ is1num = 0;
+ while(*ptr1 && isalpha((int)*ptr1)) ptr1++;
+ }
+ if(isdigit((int)*ptr2)) {
+ is2num = 1;
+ while(*ptr2 && isdigit((int)*ptr2)) ptr2++;
+ } else {
+ is2num = 0;
+ while(*ptr2 && isalpha((int)*ptr2)) ptr2++;
+ }
+
+ oldch1 = *ptr1;
+ *ptr1 = '\0';
+ oldch2 = *ptr2;
+ *ptr2 = '\0';
+
+ /* see if we ran out of segments on one string */
+ if(one == ptr1 && two != ptr2) {
+ return(is2num ? -1 : 1);
+ }
+ if(one != ptr1 && two == ptr2) {
+ return(is1num ? 1 : -1);
+ }
+
+ /* see if we have a type mismatch (ie, one is alpha and one is digits) */
+ if(is1num && !is2num) return(1);
+ if(!is1num && is2num) return(-1);
+
+ if(is1num) while(*one == '0') one++;
+ if(is2num) while(*two == '0') two++;
+
+ rc = strverscmp(one, two);
+ if(rc) return(rc);
+
+ *ptr1 = oldch1;
+ *ptr2 = oldch2;
+ one = ptr1;
+ two = ptr2;
+ }
+
+ if((!*one) && (!*two)) {
+ /* compare release numbers */
+ if(rel1 && rel2 && strlen(rel1) && strlen(rel2)) return(_alpm_versioncmp(rel1, rel2));
+ return(0);
+ }
+
+ return(*one ? 1 : -1);
+}
+
+
+pmpkg_t *_alpm_pkg_new(const char *name, const char *version)
+{
+ pmpkg_t* pkg;
+
+ ALPM_LOG_FUNC;
+
+ CALLOC(pkg, 1, sizeof(pmpkg_t), RET_ERR(PM_ERR_MEMORY, NULL));
+
+ if(name && name[0] != 0) {
+ strncpy(pkg->name, name, PKG_NAME_LEN);
+ } else {
+ pkg->name[0] = '\0';
+ }
+ if(version && version[0] != 0) {
+ strncpy(pkg->version, version, PKG_VERSION_LEN);
+ } else {
+ pkg->version[0] = '\0';
+ }
+
+ return(pkg);
+}
+
+pmpkg_t *_alpm_pkg_dup(pmpkg_t *pkg)
+{
+ pmpkg_t* newpkg;
+
+ ALPM_LOG_FUNC;
+
+ CALLOC(newpkg, 1, sizeof(pmpkg_t), RET_ERR(PM_ERR_MEMORY, NULL));
+
+ memcpy(newpkg, pkg, sizeof(pmpkg_t));
+ newpkg->licenses = alpm_list_strdup(alpm_pkg_get_licenses(pkg));
+ newpkg->conflicts = alpm_list_strdup(alpm_pkg_get_conflicts(pkg));
+ newpkg->files = alpm_list_strdup(alpm_pkg_get_files(pkg));
+ newpkg->backup = alpm_list_strdup(alpm_pkg_get_backup(pkg));
+ newpkg->depends = alpm_list_copy_data(alpm_pkg_get_depends(pkg),
+ sizeof(pmdepend_t));
+ newpkg->optdepends = alpm_list_strdup(alpm_pkg_get_optdepends(pkg));
+ newpkg->groups = alpm_list_strdup(alpm_pkg_get_groups(pkg));
+ newpkg->provides = alpm_list_strdup(alpm_pkg_get_provides(pkg));
+ newpkg->replaces = alpm_list_strdup(alpm_pkg_get_replaces(pkg));
+ newpkg->deltas = alpm_list_copy_data(alpm_pkg_get_deltas(pkg),
+ sizeof(pmdelta_t));
+ /* internal */
+ if(newpkg->origin == PKG_FROM_FILE) {
+ newpkg->origin_data.file = strdup(pkg->origin_data.file);
+ } else {
+ newpkg->origin_data.db = pkg->origin_data.db;
+ }
+
+ return(newpkg);
+}
+
+void _alpm_pkg_free(pmpkg_t *pkg)
+{
+ ALPM_LOG_FUNC;
+
+ if(pkg == NULL) {
+ return;
+ }
+
+ FREELIST(pkg->licenses);
+ FREELIST(pkg->files);
+ FREELIST(pkg->backup);
+ FREELIST(pkg->depends);
+ FREELIST(pkg->optdepends);
+ FREELIST(pkg->conflicts);
+ FREELIST(pkg->groups);
+ FREELIST(pkg->provides);
+ FREELIST(pkg->replaces);
+ FREELIST(pkg->deltas);
+ if(pkg->origin == PKG_FROM_FILE) {
+ FREE(pkg->origin_data.file);
+ }
+ FREE(pkg);
+}
+
+/* Is pkgB an upgrade for pkgA ? */
+int alpm_pkg_compare_versions(pmpkg_t *local_pkg, pmpkg_t *pkg)
+{
+ int cmp = 0;
+
+ ALPM_LOG_FUNC;
+
+ if(pkg->origin == PKG_FROM_CACHE) {
+ /* ensure we have the /desc file, which contains the 'force' option */
+ _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
+ }
+
+ /* compare versions and see if we need to upgrade */
+ cmp = _alpm_versioncmp(alpm_pkg_get_version(pkg), alpm_pkg_get_version(local_pkg));
+
+ if(cmp != 0 && pkg->force) {
+ cmp = 1;
+ _alpm_log(PM_LOG_WARNING, _("%s: forcing upgrade to version %s\n"),
+ alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
+ } else if(cmp < 0) {
+ /* local version is newer */
+ pmdb_t *db = pkg->origin_data.db;
+ _alpm_log(PM_LOG_WARNING, _("%s: local (%s) is newer than %s (%s)\n"),
+ alpm_pkg_get_name(local_pkg), alpm_pkg_get_version(local_pkg),
+ alpm_db_get_name(db), alpm_pkg_get_version(pkg));
+ cmp = 0;
+ } else if(cmp > 0) {
+ /* we have an upgrade, make sure we should actually do it */
+ if(_alpm_pkg_istoonew(pkg)) {
+ /* package too new (UpgradeDelay) */
+ _alpm_log(PM_LOG_WARNING, _("%s-%s: delaying upgrade of package (%s)\n"),
+ alpm_pkg_get_name(local_pkg), alpm_pkg_get_version(local_pkg),
+ alpm_pkg_get_version(pkg));
+ cmp = 0;
+ }
+ }
+
+ return(cmp);
+}
+
+/* Helper function for comparing packages
+ */
+int _alpm_pkg_cmp(const void *p1, const void *p2)
+{
+ pmpkg_t *pk1 = (pmpkg_t *)p1;
+ pmpkg_t *pk2 = (pmpkg_t *)p2;
+
+ return(strcmp(alpm_pkg_get_name(pk1), alpm_pkg_get_name(pk2)));
+}
+
+/* Parses the package description file for the current package
+ * TODO: this should ALL be in a backend interface (be_files), we should
+ * be dealing with the abstracted concepts only in this file
+ * Returns: 0 on success, 1 on error
+ *
+ */
+static int parse_descfile(const char *descfile, pmpkg_t *info)
+{
+ FILE* fp = NULL;
+ char line[PATH_MAX];
+ char *ptr = NULL;
+ char *key = NULL;
+ int linenum = 0;
+
+ ALPM_LOG_FUNC;
+
+ if((fp = fopen(descfile, "r")) == NULL) {
+ _alpm_log(PM_LOG_ERROR, _("could not open file %s: %s\n"), descfile, strerror(errno));
+ return(-1);
+ }
+
+ while(!feof(fp)) {
+ fgets(line, PATH_MAX, fp);
+ linenum++;
+ _alpm_strtrim(line);
+ if(strlen(line) == 0 || line[0] == '#') {
+ continue;
+ }
+ ptr = line;
+ key = strsep(&ptr, "=");
+ if(key == NULL || ptr == NULL) {
+ _alpm_log(PM_LOG_DEBUG, "%s: syntax error in description file line %d\n",
+ info->name[0] != '\0' ? info->name : "error", linenum);
+ } else {
+ _alpm_strtrim(key);
+ _alpm_strtrim(ptr);
+ if(!strcmp(key, "pkgname")) {
+ strncpy(info->name, ptr, sizeof(info->name));
+ } else if(!strcmp(key, "pkgver")) {
+ strncpy(info->version, ptr, sizeof(info->version));
+ } else if(!strcmp(key, "pkgdesc")) {
+ strncpy(info->desc, ptr, sizeof(info->desc));
+ } else if(!strcmp(key, "group")) {
+ info->groups = alpm_list_add(info->groups, strdup(ptr));
+ } else if(!strcmp(key, "url")) {
+ strncpy(info->url, ptr, sizeof(info->url));
+ } else if(!strcmp(key, "license")) {
+ info->licenses = alpm_list_add(info->licenses, strdup(ptr));
+ } else if(!strcmp(key, "builddate")) {
+ char first = tolower(ptr[0]);
+ if(first > 'a' && first < 'z') {
+ struct tm tmp_tm = {0}; //initialize to null incase of failure
+ setlocale(LC_TIME, "C");
+ strptime(ptr, "%a %b %e %H:%M:%S %Y", &tmp_tm);
+ info->builddate = mktime(&tmp_tm);
+ setlocale(LC_TIME, "");
+ } else {
+ info->builddate = atol(ptr);
+ }
+ } else if(!strcmp(key, "packager")) {
+ strncpy(info->packager, ptr, sizeof(info->packager));
+ } else if(!strcmp(key, "arch")) {
+ strncpy(info->arch, ptr, sizeof(info->arch));
+ } else if(!strcmp(key, "size")) {
+ /* size in the raw package is uncompressed (installed) size */
+ info->isize = atol(ptr);
+ } else if(!strcmp(key, "depend")) {
+ pmdepend_t *dep = alpm_splitdep(ptr);
+ info->depends = alpm_list_add(info->depends, dep);
+ } else if(!strcmp(key, "optdepend")) {
+ info->optdepends = alpm_list_add(info->optdepends, strdup(ptr));
+ } else if(!strcmp(key, "conflict")) {
+ info->conflicts = alpm_list_add(info->conflicts, strdup(ptr));
+ } else if(!strcmp(key, "replaces")) {
+ info->replaces = alpm_list_add(info->replaces, strdup(ptr));
+ } else if(!strcmp(key, "provides")) {
+ info->provides = alpm_list_add(info->provides, strdup(ptr));
+ } else if(!strcmp(key, "backup")) {
+ info->backup = alpm_list_add(info->backup, strdup(ptr));
+ } else {
+ _alpm_log(PM_LOG_DEBUG, "%s: syntax error in description file line %d\n",
+ info->name[0] != '\0' ? info->name : "error", linenum);
+ }
+ }
+ line[0] = '\0';
+ }
+ fclose(fp);
+ unlink(descfile);
+
+ return(0);
+}
+
+
+/**
+ * Load a package and create the corresponding pmpkg_t struct.
+ * @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
+ */
+pmpkg_t *_alpm_pkg_load(const char *pkgfile, unsigned short full)
+{
+ int ret = ARCHIVE_OK;
+ int config = 0;
+ int filelist = 0;
+ struct archive *archive;
+ struct archive_entry *entry;
+ pmpkg_t *info = NULL;
+ char *descfile = NULL;
+ int fd = -1;
+ alpm_list_t *all_files = NULL;
+ struct stat st;
+
+ ALPM_LOG_FUNC;
+
+ if(pkgfile == NULL || strlen(pkgfile) == 0) {
+ RET_ERR(PM_ERR_WRONG_ARGS, NULL);
+ }
+
+ if((archive = archive_read_new()) == NULL) {
+ RET_ERR(PM_ERR_LIBARCHIVE_ERROR, NULL);
+ }
+
+ archive_read_support_compression_all(archive);
+ archive_read_support_format_all(archive);
+
+ if (archive_read_open_filename(archive, pkgfile,
+ ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
+ RET_ERR(PM_ERR_PKG_OPEN, NULL);
+ }
+
+ info = _alpm_pkg_new(NULL, NULL);
+ if(info == NULL) {
+ archive_read_finish(archive);
+ RET_ERR(PM_ERR_MEMORY, NULL);
+ }
+
+ if(stat(pkgfile, &st) == 0) {
+ info->size = st.st_size;
+ }
+
+ /* TODO there is no reason to make temp files to read
+ * from a libarchive archive, it can be done by reading
+ * directly from the archive
+ * See: archive_read_data_into_buffer
+ * requires changes 'parse_descfile' as well
+ * */
+
+ /* 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
+ * as a verfication of integrity. */
+ while((ret = archive_read_next_header(archive, &entry)) == ARCHIVE_OK) {
+ const char *entry_name = archive_entry_pathname(entry);
+
+ if(strcmp(entry_name, ".PKGINFO") == 0) {
+ /* extract this file into /tmp. it has info for us */
+ descfile = strdup("/tmp/alpm_XXXXXX");
+ fd = mkstemp(descfile);
+ archive_read_data_into_fd(archive, fd);
+ /* parse the info file */
+ if(parse_descfile(descfile, info) == -1) {
+ _alpm_log(PM_LOG_ERROR, _("could not parse package description file in %s\n"),
+ pkgfile);
+ goto pkg_invalid;
+ }
+ if(!strlen(info->name)) {
+ _alpm_log(PM_LOG_ERROR, _("missing package name in %s\n"), pkgfile);
+ goto pkg_invalid;
+ }
+ if(!strlen(info->version)) {
+ _alpm_log(PM_LOG_ERROR, _("missing package version in %s\n"), pkgfile);
+ goto pkg_invalid;
+ }
+ config = 1;
+ unlink(descfile);
+ FREE(descfile);
+ close(fd);
+ continue;
+ } else if(strcmp(entry_name, ".INSTALL") == 0) {
+ info->scriptlet = 1;
+ } else if(strcmp(entry_name, ".FILELIST") == 0) {
+ /* Build info->files from the filelist */
+ FILE *fp;
+ char *fn;
+ char str[PATH_MAX+1];
+ int fd;
+
+ fn = strdup("/tmp/alpm_XXXXXX");
+ fd = mkstemp(fn);
+ archive_read_data_into_fd(archive,fd);
+ fp = fopen(fn, "r");
+ while(!feof(fp)) {
+ if(fgets(str, PATH_MAX, fp) == NULL) {
+ continue;
+ }
+ _alpm_strtrim(str);
+ info->files = alpm_list_add(info->files, strdup(str));
+ }
+ fclose(fp);
+ if(unlink(fn)) {
+ _alpm_log(PM_LOG_WARNING, _("could not remove tempfile %s\n"), fn);
+ }
+ FREE(fn);
+ close(fd);
+ filelist = 1;
+ continue;
+ } else if(*entry_name == '.') {
+ /* for now, ignore all files starting with '.' that haven't
+ * already been handled (for future possibilities) */
+ } else {
+ /* Keep track of all files so we can generate a filelist later if missing */
+ all_files = alpm_list_add(all_files, strdup(entry_name));
+ }
+
+ if(archive_read_data_skip(archive)) {
+ _alpm_log(PM_LOG_ERROR, _("error while reading package %s: %s\n"),
+ pkgfile, archive_error_string(archive));
+ pm_errno = PM_ERR_LIBARCHIVE_ERROR;
+ goto error;
+ }
+
+ /* if we are not doing a full read, see if we have all we need */
+ if(!full && config && filelist) {
+ break;
+ }
+ }
+
+ if(ret != ARCHIVE_EOF && ret != ARCHIVE_OK) { /* An error occured */
+ _alpm_log(PM_LOG_ERROR, _("error while reading package %s: %s\n"),
+ pkgfile, archive_error_string(archive));
+ pm_errno = PM_ERR_LIBARCHIVE_ERROR;
+ goto error;
+ }
+
+ if(!config) {
+ _alpm_log(PM_LOG_ERROR, _("missing package metadata in %s\n"), pkgfile);
+ goto error;
+ }
+
+ archive_read_finish(archive);
+
+ if(!filelist) {
+ _alpm_log(PM_LOG_ERROR, _("missing package filelist in %s, generating one\n"), pkgfile);
+ info->files = all_files;
+ } else {
+ FREELIST(all_files);
+ }
+
+ /* this is IMPORTANT - "checking for conflicts" requires a sorted list, so we
+ * ensure that here */
+ info->files = alpm_list_msort(info->files, alpm_list_count(info->files), _alpm_str_cmp);
+
+ /* internal */
+ info->origin = PKG_FROM_FILE;
+ info->origin_data.file = strdup(pkgfile);
+ info->infolevel = 0xFF;
+
+ return(info);
+
+pkg_invalid:
+ pm_errno = PM_ERR_PKG_INVALID;
+ if(descfile) {
+ unlink(descfile);
+ FREE(descfile);
+ }
+ if(fd != -1) {
+ close(fd);
+ }
+error:
+ _alpm_pkg_free(info);
+ archive_read_finish(archive);
+
+ return(NULL);
+}
+
+/* Test for existence of a package in a alpm_list_t*
+ * of pmpkg_t*
+ */
+pmpkg_t *_alpm_pkg_find(const char *needle, alpm_list_t *haystack)
+{
+ alpm_list_t *lp;
+
+ ALPM_LOG_FUNC;
+
+ if(needle == NULL || haystack == NULL) {
+ return(NULL);
+ }
+
+ for(lp = haystack; lp; lp = lp->next) {
+ pmpkg_t *info = lp->data;
+
+ if(info && strcmp(alpm_pkg_get_name(info), needle) == 0) {
+ return(info);
+ }
+ }
+ return(NULL);
+}
+
/* TODO this should either be public, or done somewhere else */
int _alpm_pkg_istoonew(pmpkg_t *pkg)
{
@@ -984,4 +1077,34 @@ int _alpm_pkg_istoonew(pmpkg_t *pkg)
time(&t);
return((pkg->date + handle->upgradedelay) > t);
}
+
+/** 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.
+ *
+ * @param pkg the package to test
+ *
+ * @return 1 if the package should be ignored, 0 otherwise
+ */
+int _alpm_pkg_should_ignore(pmpkg_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);
+ }
+
+ /* next see if the package is in a group that is ignored */
+ for(groups = handle->ignoregrp; 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(0);
+}
+
/* vim: set ts=2 sw=2 noet: */
generated by cgit v1.2.3-24-g4f1b (git 2.32.0) at 2024-07-12 10:45:28 +0200