Send patches - preferably formatted by git format-patch - to patches at archlinux32 dot org.
summaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/libalpm/Makefile.am10
-rw-r--r--lib/libalpm/add.c50
-rw-r--r--lib/libalpm/alpm.c24
-rw-r--r--lib/libalpm/alpm.h226
-rw-r--r--lib/libalpm/alpm_list.c114
-rw-r--r--lib/libalpm/backup.c14
-rw-r--r--lib/libalpm/base64.c190
-rw-r--r--lib/libalpm/base64.h68
-rw-r--r--lib/libalpm/be_local.c99
-rw-r--r--lib/libalpm/be_package.c100
-rw-r--r--lib/libalpm/be_sync.c96
-rw-r--r--lib/libalpm/conflict.c144
-rw-r--r--lib/libalpm/db.c247
-rw-r--r--lib/libalpm/db.h4
-rw-r--r--lib/libalpm/delta.c36
-rw-r--r--lib/libalpm/delta.h6
-rw-r--r--lib/libalpm/deps.c98
-rw-r--r--lib/libalpm/diskspace.c28
-rw-r--r--lib/libalpm/dload.c505
-rw-r--r--lib/libalpm/dload.h14
-rw-r--r--lib/libalpm/error.c28
-rw-r--r--lib/libalpm/graph.c52
-rw-r--r--lib/libalpm/graph.h32
-rw-r--r--lib/libalpm/group.c7
-rw-r--r--lib/libalpm/handle.c247
-rw-r--r--lib/libalpm/handle.h20
-rw-r--r--lib/libalpm/log.c7
-rw-r--r--lib/libalpm/package.c66
-rw-r--r--lib/libalpm/package.h10
-rw-r--r--lib/libalpm/pkghash.c36
-rw-r--r--lib/libalpm/remove.c29
-rw-r--r--lib/libalpm/signing.c410
-rw-r--r--lib/libalpm/signing.h29
-rw-r--r--lib/libalpm/sync.c264
-rw-r--r--lib/libalpm/trans.c68
-rw-r--r--lib/libalpm/util.c107
-rw-r--r--lib/libalpm/util.h8
-rw-r--r--lib/libalpm/version.c14
38 files changed, 2220 insertions, 1287 deletions
diff --git a/lib/libalpm/Makefile.am b/lib/libalpm/Makefile.am
index 1bda5714..b2b6d0d2 100644
--- a/lib/libalpm/Makefile.am
+++ b/lib/libalpm/Makefile.am
@@ -35,13 +35,14 @@ 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 \
remove.h remove.c \
+ signing.c signing.h \
sync.h sync.c \
trans.h trans.c \
util.h util.c \
@@ -52,7 +53,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 702b12e9..ee56e876 100644
--- a/lib/libalpm/add.c
+++ b/lib/libalpm/add.c
@@ -44,15 +44,10 @@
#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)
- */
+/** Add a package to the transaction. */
int SYMEXPORT alpm_add_pkg(pmpkg_t *pkg)
{
const char *pkgname, *pkgver;
@@ -68,11 +63,10 @@ int SYMEXPORT alpm_add_pkg(pmpkg_t *pkg)
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;
- 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);
@@ -91,7 +85,7 @@ int SYMEXPORT alpm_add_pkg(pmpkg_t *pkg)
/* with the NEEDED flag, packages up to date are not reinstalled */
_alpm_log(PM_LOG_WARNING, _("%s-%s is up to date -- skipping\n"),
localpkgname, localpkgver);
- return(0);
+ return 0;
} else {
_alpm_log(PM_LOG_WARNING, _("%s-%s is up to date -- reinstalling\n"),
localpkgname, localpkgver);
@@ -105,11 +99,11 @@ int SYMEXPORT alpm_add_pkg(pmpkg_t *pkg)
/* 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",
+ _alpm_log(PM_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,
@@ -132,9 +126,9 @@ static int perform_extraction(struct archive *archive,
origname, archive_error_string(archive));
alpm_logaction("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,
@@ -169,7 +163,7 @@ static int extract_single_file(struct archive *archive,
* already been handled (for future possibilities) */
_alpm_log(PM_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);
@@ -182,7 +176,7 @@ static int extract_single_file(struct archive *archive,
alpm_logaction("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
@@ -226,13 +220,13 @@ static int extract_single_file(struct archive *archive,
_alpm_log(PM_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"),
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 */
@@ -241,13 +235,13 @@ static int extract_single_file(struct archive *archive,
_alpm_log(PM_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"),
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 */
@@ -299,7 +293,7 @@ static int extract_single_file(struct archive *archive,
/* error */
FREE(hash_orig);
FREE(entryname_orig);
- return(1);
+ return 1;
}
hash_local = alpm_compute_md5sum(filename);
@@ -442,7 +436,7 @@ static int extract_single_file(struct archive *archive,
if(ret == 1) {
/* error */
FREE(entryname_orig);
- return(1);
+ return 1;
}
/* calculate an hash if this is in newpkg's backup */
@@ -469,7 +463,7 @@ static int extract_single_file(struct archive *archive,
}
}
FREE(entryname_orig);
- return(errors);
+ return errors;
}
static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
@@ -559,7 +553,7 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
_alpm_log(PM_LOG_DEBUG, "extracting files\n");
- if ((archive = archive_read_new()) == NULL) {
+ if((archive = archive_read_new()) == NULL) {
pm_errno = PM_ERR_LIBARCHIVE;
ret = -1;
goto cleanup;
@@ -705,7 +699,7 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
cleanup:
_alpm_pkg_free(oldpkg);
- return(ret);
+ return ret;
}
int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
@@ -720,7 +714,7 @@ int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
if(trans->add == NULL) {
- return(0);
+ return 0;
}
pkg_count = alpm_list_count(trans->add);
@@ -729,7 +723,7 @@ 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) {
if(handle->trans->state == STATE_INTERRUPTED) {
- return(ret);
+ return ret;
}
pmpkg_t *newpkg = (pmpkg_t *)targ->data;
@@ -750,7 +744,7 @@ int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
_alpm_ldconfig(handle->root);
}
- return(ret);
+ return ret;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/alpm.c b/lib/libalpm/alpm.c
index a60a4bb6..bafd922b 100644
--- a/lib/libalpm/alpm.c
+++ b/lib/libalpm/alpm.c
@@ -23,9 +23,8 @@
#include "config.h"
-/* connection caching setup */
-#ifdef HAVE_LIBFETCH
-#include <fetch.h>
+#ifdef HAVE_LIBCURL
+#include <curl/curl.h>
#endif
/* libalpm */
@@ -58,18 +57,19 @@ int SYMEXPORT alpm_initialize(void)
/* error code should be set */
_alpm_handle_free(handle);
handle = NULL;
- return(-1);
+ return -1;
}
#ifdef ENABLE_NLS
bindtextdomain("libalpm", LOCALEDIR);
#endif
-#ifdef HAVE_LIBFETCH
- fetchConnectionCacheInit(5, 1);
+#ifdef HAVE_LIBCURL
+ curl_global_init(CURL_GLOBAL_SSL);
+ handle->curl = curl_easy_init();
#endif
- return(0);
+ return 0;
}
/** Release the library. This should be the last alpm call you make.
@@ -91,17 +91,17 @@ int SYMEXPORT alpm_release(void)
}
if(alpm_db_unregister_all() == -1) {
- return(-1);
+ return -1;
}
_alpm_handle_free(handle);
handle = NULL;
-#ifdef HAVE_LIBFETCH
- fetchConnectionCacheClose();
+#ifdef HAVE_LIBCURL
+ curl_global_cleanup();
#endif
- return(0);
+ return 0;
}
/** @} */
@@ -112,7 +112,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..5af843c4 100644
--- a/lib/libalpm/alpm.h
+++ b/lib/libalpm/alpm.h
@@ -45,6 +45,32 @@ extern "C" {
*/
/*
+ * Enumerations
+ * These ones are used in multiple contexts, so are forward-declared.
+ */
+
+/**
+ * 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;
+
+/**
+ * GPG signature verification options
+ */
+typedef enum _pgp_verify_t {
+ PM_PGP_VERIFY_UNKNOWN,
+ PM_PGP_VERIFY_NEVER,
+ PM_PGP_VERIFY_OPTIONAL,
+ PM_PGP_VERIFY_ALWAYS
+} pgp_verify_t;
+
+/*
* Structures
*/
@@ -70,7 +96,9 @@ const char *alpm_version(void);
* Logging facilities
*/
-/* Levels */
+/**
+ * Logging Levels
+ */
typedef enum _pmloglevel_t {
PM_LOG_ERROR = 1,
PM_LOG_WARNING = (1 << 1),
@@ -85,9 +113,16 @@ int alpm_logaction(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
@@ -109,44 +144,48 @@ char *alpm_fetch_pkgurl(const char *url);
* @{
*/
-/** @name The logging callback. */
-/* @{ */
+/** Returns the callback used for logging. */
alpm_cb_log alpm_option_get_logcb(void);
-void alpm_option_set_logcb(alpm_cb_log cb);
-/* @} */
+/** Sets the callback used for logging. */
+int alpm_option_set_logcb(alpm_cb_log cb);
-/** Get/set the download progress callback. */
+/** Returns the callback used to report download progress. */
alpm_cb_download alpm_option_get_dlcb(void);
-void alpm_option_set_dlcb(alpm_cb_download cb);
+/** Sets the callback used to report download progress. */
+int alpm_option_set_dlcb(alpm_cb_download cb);
-/** Get/set the downloader callback. */
+/** Returns the downloading callback. */
alpm_cb_fetch alpm_option_get_fetchcb(void);
-void alpm_option_set_fetchcb(alpm_cb_fetch cb);
+/** Sets the downloading callback. */
+int alpm_option_set_fetchcb(alpm_cb_fetch cb);
-/** Get/set the callback used when download size is known. */
+/** Returns the callback used to report total download size. */
alpm_cb_totaldl alpm_option_get_totaldlcb(void);
-void alpm_option_set_totaldlcb(alpm_cb_totaldl cb);
+/** Sets the callback used to report total download size. */
+int alpm_option_set_totaldlcb(alpm_cb_totaldl cb);
-/** Get/set the root of the destination filesystem. */
+/** Returns the root of the destination filesystem. */
const char *alpm_option_get_root(void);
+/** Sets the root of the destination filesystem. */
int alpm_option_set_root(const char *root);
-/** Get/set the path to the database directory. */
+/** Returns the path to the database directory. */
const char *alpm_option_get_dbpath(void);
+/** Sets the path to the database directory. */
int alpm_option_set_dbpath(const char *dbpath);
-/** Get/set the list of package cache directories. */
+/** @name Accessors to the list of package cache directories.
+ * @{
+ */
alpm_list_t *alpm_option_get_cachedirs(void);
-void alpm_option_set_cachedirs(alpm_list_t *cachedirs);
-
-/** Add a single directory to the package cache paths. */
+int alpm_option_set_cachedirs(alpm_list_t *cachedirs);
int alpm_option_add_cachedir(const char *cachedir);
-
-/** Remove a single directory from the package cache paths. */
int alpm_option_remove_cachedir(const char *cachedir);
+/** @} */
-/** Get/set the logfile name. */
+/** Returns the logfile name. */
const char *alpm_option_get_logfile(void);
+/** Sets the logfile name. */
int alpm_option_set_logfile(const char *logfile);
/** Get the name of the database lock file.
@@ -158,51 +197,76 @@ int alpm_option_set_logfile(const char *logfile);
*/
const char *alpm_option_get_lockfile(void);
-/** Get/set whether to use syslog (0 is FALSE, TRUE otherwise). */
+/** Returns the signature directory path. */
+const char *alpm_option_get_signaturedir(void);
+/** Sets the signature directory path. */
+int alpm_option_set_signaturedir(const char *signaturedir);
+
+/** Returns whether to use syslog (0 is FALSE, TRUE otherwise). */
int alpm_option_get_usesyslog(void);
-void alpm_option_set_usesyslog(int usesyslog);
+/** Sets whether to use syslog (0 is FALSE, TRUE otherwise). */
+int 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(void);
-void alpm_option_add_noupgrade(const char *pkg);
-void alpm_option_set_noupgrades(alpm_list_t *noupgrade);
+int alpm_option_add_noupgrade(const char *pkg);
+int 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(void);
-void alpm_option_add_noextract(const char *pkg);
-void alpm_option_set_noextracts(alpm_list_t *noextract);
+int alpm_option_add_noextract(const char *pkg);
+int 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(void);
-void alpm_option_add_ignorepkg(const char *pkg);
-void alpm_option_set_ignorepkgs(alpm_list_t *ignorepkgs);
+int alpm_option_add_ignorepkg(const char *pkg);
+int 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_ignoregrps(void);
-void alpm_option_add_ignoregrp(const char *grp);
-void alpm_option_set_ignoregrps(alpm_list_t *ignoregrps);
+int alpm_option_add_ignoregrp(const char *grp);
+int alpm_option_set_ignoregrps(alpm_list_t *ignoregrps);
int alpm_option_remove_ignoregrp(const char *grp);
+/** @} */
-/** Get/set the targeted architecture. */
+/** Returns the targeted architecture. */
const char *alpm_option_get_arch(void);
-void alpm_option_set_arch(const char *arch);
+/** Sets the targeted architecture. */
+int alpm_option_set_arch(const char *arch);
int alpm_option_get_usedelta(void);
-void alpm_option_set_usedelta(int usedelta);
+int alpm_option_set_usedelta(int usedelta);
int alpm_option_get_checkspace(void);
-void alpm_option_set_checkspace(int checkspace);
+int alpm_option_set_checkspace(int checkspace);
-/** @} */
+pgp_verify_t alpm_option_get_default_sigverify(void);
+int alpm_option_set_default_sigverify(pgp_verify_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.
@@ -253,12 +317,14 @@ const char *alpm_db_get_name(const pmdb_t *db);
*/
const char *alpm_db_get_url(const pmdb_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)
+/** @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 pmdb_t *db);
+int alpm_db_set_servers(pmdb_t *db, alpm_list_t *servers);
+int alpm_db_add_server(pmdb_t *db, const char *url);
+int alpm_db_remove_server(pmdb_t *db, const char *url);
+/** @} */
int alpm_db_update(int level, pmdb_t *db);
@@ -288,10 +354,10 @@ pmgrp_t *alpm_db_readgrp(pmdb_t *db, const char *name);
*/
alpm_list_t *alpm_db_get_grpcache(pmdb_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);
@@ -313,14 +379,18 @@ 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 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 check_sig 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(const char *filename, int full, pgp_verify_t check_sig,
+ pmpkg_t **pkg);
/** Free a package.
* @param pkg package pointer to free
@@ -498,9 +568,9 @@ alpm_list_t *alpm_pkg_get_files(pmpkg_t *pkg);
*/
alpm_list_t *alpm_pkg_get_backup(pmpkg_t *pkg);
-/** Returns the database containing 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.
+ * 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.
*/
@@ -534,6 +604,9 @@ size_t alpm_pkg_changelog_read(void *ptr, size_t size,
int alpm_pkg_changelog_close(const pmpkg_t *pkg, void *fp);
+/** Returns whether the package has an install scriptlet.
+ * @return 0 if FALSE, TRUE otherwise
+ */
int alpm_pkg_has_scriptlet(pmpkg_t *pkg);
/** Returns the size of download.
@@ -550,6 +623,15 @@ alpm_list_t *alpm_pkg_unused_deltas(pmpkg_t *pkg);
/** @} */
/*
+ * Signatures
+ */
+
+int alpm_pkg_check_pgp_signature(pmpkg_t *pkg);
+
+int alpm_db_check_pgp_signature(pmdb_t *db);
+int alpm_db_set_pgp_verify(pmdb_t *db, pgp_verify_t verify);
+
+/*
* Deltas
*/
@@ -726,6 +808,9 @@ typedef void (*alpm_trans_cb_conv)(pmtransconv_t, void *, void *,
/** Transaction Progress callback */
typedef void (*alpm_trans_cb_progress)(pmtransprog_t, const char *, int, size_t, size_t);
+/** Returns the bitfield of flags for the current transaction.
+ * @sa _pmtransflag_t
+ */
int alpm_trans_get_flags(void);
/** Returns a list of packages added by the transaction.
@@ -776,9 +861,27 @@ int alpm_trans_release(void);
/** @name Common Transactions */
/** @{ */
+
+/** Search for packages to upgrade and add them to the transaction.
+ * @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(int enable_downgrade);
+
+/** 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 pkg the package to add
+ * @return 0 on success, -1 on error (pm_errno is set accordingly)
+ */
int alpm_add_pkg(pmpkg_t *pkg);
+
+/** Add a package removal action to the transaction.
+ * @param pkg the package to uninstall
+ * @return 0 on success, -1 on error (pm_errno is set accordingly)
+ */
int alpm_remove_pkg(pmpkg_t *pkg);
+
/** @} */
/** @addtogroup alpm_api_depends Dependency Functions
@@ -916,6 +1019,10 @@ enum _pmerrno_t {
PM_ERR_PKG_INVALID_NAME,
PM_ERR_PKG_INVALID_ARCH,
PM_ERR_PKG_REPO_NOT_FOUND,
+ /* Signatures */
+ PM_ERR_SIG_MISSINGDIR,
+ PM_ERR_SIG_INVALID,
+ PM_ERR_SIG_UNKNOWN,
/* Deltas */
PM_ERR_DLT_INVALID,
PM_ERR_DLT_PATCHFAILED,
@@ -929,8 +1036,9 @@ enum _pmerrno_t {
PM_ERR_INVALID_REGEX,
/* External library errors */
PM_ERR_LIBARCHIVE,
- PM_ERR_LIBFETCH,
- PM_ERR_EXTERNAL_DOWNLOAD
+ PM_ERR_LIBCURL,
+ PM_ERR_EXTERNAL_DOWNLOAD,
+ PM_ERR_GPGME
};
/** The number of the last error that occurred. */
diff --git a/lib/libalpm/alpm_list.c b/lib/libalpm/alpm_list.c
index 42ef367a..c2b30adc 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,7 +501,7 @@ 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 */
@@ -517,9 +516,9 @@ alpm_list_t SYMEXPORT *alpm_list_reverse(alpm_list_t *list)
inline alpm_list_t SYMEXPORT *alpm_list_first(const alpm_list_t *list)
{
if(list) {
- return((alpm_list_t*)list);
+ return (alpm_list_t *)list;
} else {
- return(NULL);
+ return NULL;
}
}
@@ -537,7 +536,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 +549,9 @@ 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;
}
}
@@ -566,9 +565,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 +580,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 +601,7 @@ size_t SYMEXPORT alpm_list_count(const alpm_list_t *list)
++i;
lp = lp->next;
}
- return(i);
+ return i;
}
/**
@@ -620,17 +619,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 +642,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 +659,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 +688,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 +706,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 +745,7 @@ alpm_list_t SYMEXPORT *alpm_list_diff(const alpm_list_t *lhs,
alpm_list_free(left);
alpm_list_free(right);
- return(ret);
+ return ret;
}
/** @} */
diff --git a/lib/libalpm/backup.c b/lib/libalpm/backup.c
index ca955ca4..7df97471 100644
--- a/lib/libalpm/backup.c
+++ b/lib/libalpm/backup.c
@@ -47,7 +47,7 @@ static int backup_split(const char *string, char **file, char **hash)
/* don't need our dup as the fname wasn't requested, so free it */
FREE(str);
}
- return(0);
+ return 0;
}
*ptr = '\0';
ptr++;
@@ -59,21 +59,21 @@ static int backup_split(const char *string, char **file, char **hash)
*hash = strdup(ptr);
}
FREE(str);
- return(1);
+ return 1;
}
char *_alpm_backup_file(const char *string)
{
char *file = NULL;
backup_split(string, &file, NULL);
- return(file);
+ return file;
}
char *_alpm_backup_hash(const char *string)
{
char *hash = NULL;
backup_split(string, NULL, &hash);
- return(hash);
+ return hash;
}
/* Look for a filename in a pmpkg_t.backup list. If we find it,
@@ -86,7 +86,7 @@ char *_alpm_needbackup(const char *file, const alpm_list_t *backup)
ALPM_LOG_FUNC;
if(file == NULL || backup == NULL) {
- return(NULL);
+ return NULL;
}
/* run through the backup list and parse out the hash for our file */
@@ -101,13 +101,13 @@ char *_alpm_needbackup(const char *file, const alpm_list_t *backup)
}
if(strcmp(file, filename) == 0) {
FREE(filename);
- return(hash);
+ return hash;
}
FREE(filename);
FREE(hash);
}
- return(NULL);
+ return NULL;
}
/* vim: set ts=2 sw=2 noet: */
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..36105452 100644
--- a/lib/libalpm/be_local.c
+++ b/lib/libalpm/be_local.c
@@ -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,16 +39,13 @@
#include "alpm.h"
#include "handle.h"
#include "package.h"
-#include "group.h"
#include "deps.h"
-#include "dload.h"
#define LAZY_LOAD(info, errret) \
do { \
ALPM_LOG_FUNC; \
- ASSERT(handle != NULL, return(errret)); \
- ASSERT(pkg != NULL, return(errret)); \
+ ASSERT(handle != NULL, return (errret)); \
if(pkg->origin != PKG_FROM_FILE && !(pkg->infolevel & info)) { \
_alpm_local_db_read(pkg->origin_data.db, pkg, info); \
} \
@@ -71,18 +64,6 @@ static const char *_cache_get_filename(pmpkg_t *pkg)
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)
{
LAZY_LOAD(INFRQ_DESC, NULL);
@@ -160,8 +141,7 @@ static int _cache_has_scriptlet(pmpkg_t *pkg)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(-1));
- ASSERT(pkg != NULL, return(-1));
+ ASSERT(handle != NULL, return -1);
if(!(pkg->infolevel & INFRQ_SCRIPTLET)) {
_alpm_local_db_read(pkg->origin_data.db, pkg, INFRQ_SCRIPTLET);
@@ -200,7 +180,7 @@ static alpm_list_t *_cache_get_replaces(pmpkg_t *pkg)
}
/* local packages can not have deltas */
-static alpm_list_t *_cache_get_deltas(pmpkg_t *pkg)
+static alpm_list_t *_cache_get_deltas(pmpkg_t UNUSED *pkg)
{
return NULL;
}
@@ -210,8 +190,7 @@ static alpm_list_t *_cache_get_files(pmpkg_t *pkg)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(pkg != NULL, return(NULL));
+ ASSERT(handle != NULL, return NULL);
if(pkg->origin == PKG_FROM_LOCALDB
&& !(pkg->infolevel & INFRQ_FILES)) {
@@ -225,8 +204,7 @@ static alpm_list_t *_cache_get_backup(pmpkg_t *pkg)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(pkg != NULL, return(NULL));
+ ASSERT(handle != NULL, return NULL);
if(pkg->origin == PKG_FROM_LOCALDB
&& !(pkg->infolevel & INFRQ_FILES)) {
@@ -246,8 +224,7 @@ static void *_cache_changelog_open(pmpkg_t *pkg)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(pkg != NULL, return(NULL));
+ ASSERT(handle != NULL, return NULL);
char clfile[PATH_MAX];
snprintf(clfile, PATH_MAX, "%s/%s/%s-%s/changelog",
@@ -268,18 +245,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 pmpkg_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 +257,9 @@ 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 pmpkg_t UNUSED *pkg, void *fp)
{
- return( fclose((FILE*)fp) );
+ return fclose((FILE *)fp);
}
@@ -299,8 +269,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,
@@ -345,14 +313,14 @@ static int checkdbdir(pmdb_t *db)
RET_ERR(PM_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,12 +329,12 @@ 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)
@@ -391,7 +359,7 @@ static int local_db_populate(pmdb_t *db)
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);
}
@@ -467,7 +435,7 @@ static int local_db_populate(pmdb_t *db)
}
/* add to the collection */
- _alpm_log(PM_LOG_DEBUG, "adding '%s' to package cache for db '%s'\n",
+ _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++;
@@ -477,7 +445,10 @@ 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(PM_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 */
@@ -491,7 +462,7 @@ static char *get_pkgpath(pmdb_t *db, pmpkg_t *info)
len = strlen(dbpath) + strlen(info->name) + strlen(info->version) + 3;
MALLOC(pkgpath, len, RET_ERR(PM_ERR_MEMORY, NULL));
sprintf(pkgpath, "%s%s-%s/", dbpath, info->name, info->version);
- return(pkgpath);
+ return pkgpath;
}
@@ -510,14 +481,14 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
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);
+ 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);
+ return -1;
}
/* bitmask logic here:
@@ -527,7 +498,7 @@ 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;
}
_alpm_log(PM_LOG_FUNCTION, "loading package data for %s : level=0x%x\n",
info->name, inforeq);
@@ -707,14 +678,14 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
info->infolevel |= inforeq;
free(pkgpath);
- return(0);
+ return 0;
error:
free(pkgpath);
if(fp) {
fclose(fp);
}
- return(-1);
+ return -1;
}
int _alpm_local_db_prepare(pmdb_t *db, pmpkg_t *info)
@@ -724,7 +695,7 @@ int _alpm_local_db_prepare(pmdb_t *db, pmpkg_t *info)
char *pkgpath = NULL;
if(checkdbdir(db) != 0) {
- return(-1);
+ return -1;
}
oldmask = umask(0000);
@@ -738,7 +709,7 @@ int _alpm_local_db_prepare(pmdb_t *db, pmpkg_t *info)
free(pkgpath);
umask(oldmask);
- return(retval);
+ return retval;
}
int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
@@ -753,7 +724,7 @@ int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
ALPM_LOG_FUNC;
if(db == NULL || info == NULL) {
- return(-1);
+ return -1;
}
pkgpath = get_pkgpath(db, info);
@@ -762,7 +733,7 @@ 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 */
@@ -905,7 +876,7 @@ cleanup:
fclose(fp);
}
- return(retval);
+ return retval;
}
int _alpm_local_db_remove(pmdb_t *db, pmpkg_t *info)
@@ -926,7 +897,7 @@ int _alpm_local_db_remove(pmdb_t *db, pmpkg_t *info)
if(ret != 0) {
ret = -1;
}
- return(ret);
+ return ret;
}
static int local_db_version(pmdb_t *db)
@@ -978,7 +949,7 @@ done:
}
_alpm_log(PM_LOG_DEBUG, "local database version %d\n", version);
- return(version);
+ return version;
}
struct db_operations local_db_ops = {
@@ -1002,7 +973,7 @@ pmdb_t *_alpm_db_register_local(void)
db->ops = &local_db_ops;
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..9e59d69a 100644
--- a/lib/libalpm/be_package.c
+++ b/lib/libalpm/be_package.c
@@ -20,10 +20,8 @@
#include "config.h"
-#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <limits.h>
#include <errno.h>
/* libarchive */
@@ -47,7 +45,7 @@ static void *_package_changelog_open(pmpkg_t *pkg)
{
ALPM_LOG_FUNC;
- ASSERT(pkg != NULL, return(NULL));
+ ASSERT(pkg != NULL, return NULL);
struct archive *archive = NULL;
struct archive_entry *entry;
@@ -60,7 +58,7 @@ static void *_package_changelog_open(pmpkg_t *pkg)
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);
}
@@ -69,14 +67,14 @@ static void *_package_changelog_open(pmpkg_t *pkg)
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,18 @@ 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 pmpkg_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);
+ return 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 +106,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 pmpkg_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,7 +127,7 @@ 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;
}
/**
@@ -226,7 +216,7 @@ static int parse_descfile(struct archive *a, pmpkg_t *newpkg)
line[0] = '\0';
}
- return(0);
+ return 0;
}
/**
@@ -236,9 +226,10 @@ static int parse_descfile(struct archive *a, pmpkg_t *newpkg)
* through the full archive
* @return An information filled pmpkg_t struct
*/
-static pmpkg_t *pkg_load(const char *pkgfile, int full)
+pmpkg_t *_alpm_pkg_load_internal(const char *pkgfile, int full,
+ const char *md5sum, const char *base64_sig, pgp_verify_t check_sig)
{
- int ret = ARCHIVE_OK;
+ int ret;
int config = 0;
struct archive *archive;
struct archive_entry *entry;
@@ -251,31 +242,54 @@ static pmpkg_t *pkg_load(const char *pkgfile, int full)
RET_ERR(PM_ERR_WRONG_ARGS, NULL);
}
- if(stat(pkgfile, &st) != 0) {
+ /* attempt to stat the package file, ensure it exists */
+ if(stat(pkgfile, &st) == 0) {
+ newpkg = _alpm_pkg_new();
+ if(newpkg == NULL) {
+ RET_ERR(PM_ERR_MEMORY, NULL);
+ }
+ newpkg->filename = strdup(pkgfile);
+ newpkg->size = st.st_size;
+ } else {
+ /* couldn't stat the pkgfile, return an error */
RET_ERR(PM_ERR_PKG_OPEN, NULL);
}
+ /* first steps- validate the package file */
+ _alpm_log(PM_LOG_DEBUG, "md5sum: %s\n", md5sum);
+ if(md5sum) {
+ _alpm_log(PM_LOG_DEBUG, "checking md5sum for %s\n", pkgfile);
+ if(_alpm_test_md5sum(pkgfile, md5sum) != 0) {
+ alpm_pkg_free(newpkg);
+ RET_ERR(PM_ERR_PKG_INVALID, NULL);
+ }
+ }
+
+ _alpm_log(PM_LOG_DEBUG, "base64_sig: %s\n", base64_sig);
+ if(check_sig != PM_PGP_VERIFY_NEVER) {
+ _alpm_log(PM_LOG_DEBUG, "checking signature for %s\n", pkgfile);
+ ret = _alpm_gpgme_checksig(pkgfile, base64_sig);
+ if((check_sig == PM_PGP_VERIFY_ALWAYS && ret != 0) ||
+ (check_sig == PM_PGP_VERIFY_OPTIONAL && ret == 1)) {
+ RET_ERR(PM_ERR_SIG_INVALID, NULL);
+ }
+ }
+
+ /* next- try to create an archive object to read in the package */
if((archive = archive_read_new()) == NULL) {
+ alpm_pkg_free(newpkg);
RET_ERR(PM_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) {
+ alpm_pkg_free(newpkg);
RET_ERR(PM_ERR_PKG_OPEN, NULL);
}
- newpkg = _alpm_pkg_new();
- if(newpkg == NULL) {
- archive_read_finish(archive);
- RET_ERR(PM_ERR_MEMORY, NULL);
- }
-
- newpkg->filename = strdup(pkgfile);
- newpkg->size = st.st_size;
-
_alpm_log(PM_LOG_DEBUG, "starting package load for %s\n", pkgfile);
/* If full is false, only read through the archive until we find our needed
@@ -340,7 +354,6 @@ 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();
@@ -356,7 +369,7 @@ static pmpkg_t *pkg_load(const char *pkgfile, int full)
newpkg->infolevel = INFRQ_BASE | INFRQ_DESC;
}
- return(newpkg);
+ return newpkg;
pkg_invalid:
pm_errno = PM_ERR_PKG_INVALID;
@@ -364,25 +377,24 @@ 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(const char *filename, int full,
+ pgp_verify_t check_sig, pmpkg_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));
- *pkg = pkg_load(filename, full);
+ *pkg = _alpm_pkg_load_internal(filename, full, NULL, NULL, check_sig);
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..9d85a454 100644
--- a/lib/libalpm/be_sync.c
+++ b/lib/libalpm/be_sync.c
@@ -20,8 +20,7 @@
#include "config.h"
-#include <errno.h>
-#include <limits.h>
+#include <sys/stat.h>
/* libarchive */
#include <archive.h>
@@ -79,26 +78,21 @@
*/
int SYMEXPORT alpm_db_update(int force, pmdb_t *db)
{
- char *dbfile, *syncpath;
+ char *syncpath;
const char *dbpath;
+ alpm_list_t *i;
struct stat buf;
size_t len;
- int ret;
+ int ret = -1;
mode_t oldmask;
+ pgp_verify_t check_sig;
ALPM_LOG_FUNC;
/* 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));
-
- if(!alpm_list_find_ptr(handle->dbs_sync, db)) {
- RET_ERR(PM_ERR_DB_NOT_FOUND, -1);
- }
-
- len = strlen(db->treename) + 4;
- MALLOC(dbfile, len, RET_ERR(PM_ERR_MEMORY, -1));
- sprintf(dbfile, "%s.db", db->treename);
+ ASSERT(db->servers != NULL, RET_ERR(PM_ERR_SERVER_NONE, -1));
dbpath = alpm_option_get_dbpath();
len = strlen(dbpath) + 6;
@@ -112,38 +106,67 @@ int SYMEXPORT alpm_db_update(int force, pmdb_t *db)
_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);
}
} 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);
}
}
- ret = _alpm_download_single_file(dbfile, db->servers, syncpath, force);
- free(dbfile);
- free(syncpath);
- umask(oldmask);
+ check_sig = _alpm_db_get_sigverify_level(db);
+
+ for(i = db->servers; i; i = i->next) {
+ const char *server = i->data;
+ char *fileurl;
+ size_t len;
+ int sig_ret = 0;
+
+ /* print server + filename into a buffer (leave space for .sig) */
+ len = strlen(server) + strlen(db->treename) + 9;
+ CALLOC(fileurl, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, -1));
+ snprintf(fileurl, len, "%s/%s.db", server, db->treename);
+
+ ret = _alpm_download(fileurl, syncpath, force, 0, 0);
+
+ if(ret == 0 && (check_sig == PM_PGP_VERIFY_ALWAYS ||
+ check_sig == PM_PGP_VERIFY_OPTIONAL)) {
+ int errors_ok = (check_sig == PM_PGP_VERIFY_OPTIONAL);
+ /* if we downloaded a DB, we want the .sig from the same server */
+ snprintf(fileurl, len, "%s/%s.db.sig", server, db->treename);
+
+ sig_ret = _alpm_download(fileurl, syncpath, 1, 0, errors_ok);
+ /* errors_ok suppresses error messages, but not the return code */
+ sig_ret = errors_ok ? 0 : sig_ret;
+ }
+
+ FREE(fileurl);
+ if(ret != -1 && sig_ret != -1) {
+ break;
+ }
+ }
if(ret == 1) {
/* files match, do nothing */
pm_errno = 0;
- return(1);
+ 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);
+ goto cleanup;
}
/* Cache needs to be rebuilt */
_alpm_db_free_pkgcache(db);
- return(0);
+cleanup:
+
+ free(syncpath);
+ umask(oldmask);
+ return ret;
}
/* Forward decl so I don't reorganize the whole file right now */
@@ -206,7 +229,7 @@ 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)
@@ -305,8 +328,10 @@ static int sync_db_populate(pmdb_t *db)
db->pkgcache->list = alpm_list_msort(db->pkgcache->list, (size_t)count, _alpm_pkg_cmp);
}
archive_read_finish(archive);
+ _alpm_log(PM_LOG_DEBUG, "added %d packages to package cache for db '%s'\n",
+ count, db->treename);
- return(count);
+ return count;
}
#define READ_NEXT(s) do { \
@@ -346,7 +371,7 @@ static int sync_db_read(pmdb_t *db, struct archive *archive,
}
if(entryname == NULL) {
_alpm_log(PM_LOG_DEBUG, "invalid archive entry provided to _alpm_sync_db_read, skipping\n");
- return(-1);
+ return -1;
}
_alpm_log(PM_LOG_FUNCTION, "loading package data from archive entry %s\n",
@@ -377,7 +402,7 @@ static int sync_db_read(pmdb_t *db, struct archive *archive,
if(pkg == NULL) {
_alpm_log(PM_LOG_DEBUG, "package %s not found in %s sync database",
pkgname, db->treename);
- return(-1);
+ return -1;
}
if(strcmp(filename, "desc") == 0 || strcmp(filename, "depends") == 0
@@ -434,8 +459,7 @@ static int sync_db_read(pmdb_t *db, struct archive *archive,
/* we don't do anything with this value right now */
READ_NEXT(line);
} 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) {
@@ -470,12 +494,12 @@ static int sync_db_read(pmdb_t *db, struct archive *archive,
error:
FREE(pkgname);
/* TODO: return 0 always? */
- return(0);
+ return 0;
}
-static int sync_db_version(pmdb_t *db)
+static int sync_db_version(pmdb_t UNUSED *db)
{
- return(2);
+ return 2;
}
struct db_operations sync_db_ops = {
@@ -487,18 +511,8 @@ struct db_operations sync_db_ops = {
pmdb_t *_alpm_db_register_sync(const char *treename)
{
pmdb_t *db;
- alpm_list_t *i;
ALPM_LOG_FUNC;
-
- for(i = handle->dbs_sync; i; i = i->next) {
- pmdb_t *sdb = i->data;
- if(strcmp(treename, sdb->treename) == 0) {
- _alpm_log(PM_LOG_DEBUG, "attempt to re-register the '%s' database, using existing\n", sdb->treename);
- return sdb;
- }
- }
-
_alpm_log(PM_LOG_DEBUG, "registering sync database '%s'\n", treename);
db = _alpm_db_new(treename, 0);
@@ -508,7 +522,7 @@ pmdb_t *_alpm_db_register_sync(const char *treename)
db->ops = &sync_db_ops;
handle->dbs_sync = alpm_list_add(handle->dbs_sync, db);
- return(db);
+ return db;
}
diff --git a/lib/libalpm/conflict.c b/lib/libalpm/conflict.c
index 6faced16..fbc988bd 100644
--- a/lib/libalpm/conflict.c
+++ b/lib/libalpm/conflict.c
@@ -53,7 +53,7 @@ pmconflict_t *_alpm_conflict_new(const char *package1, const char *package2,
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)
@@ -73,7 +73,7 @@ pmconflict_t *_alpm_conflict_dup(const pmconflict_t *conflict)
STRDUP(newconflict->package2, conflict->package2, RET_ERR(PM_ERR_MEMORY, NULL));
STRDUP(newconflict->reason, conflict->reason, RET_ERR(PM_ERR_MEMORY, NULL));
- return(newconflict);
+ return newconflict;
}
static int conflict_isin(pmconflict_t *needle, alpm_list_t *haystack)
@@ -90,11 +90,11 @@ static int conflict_isin(pmconflict_t *needle, alpm_list_t *haystack)
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
@@ -173,7 +173,7 @@ alpm_list_t *_alpm_innerconflicts(alpm_list_t *packages)
_alpm_log(PM_LOG_DEBUG, "check targets vs targets\n");
check_conflict(packages, packages, &baddeps, 0);
- return(baddeps);
+ return baddeps;
}
/* Check for target vs (db - target) conflicts
@@ -187,7 +187,7 @@ alpm_list_t *_alpm_outerconflicts(pmdb_t *db, alpm_list_t *packages)
ALPM_LOG_FUNC;
if(db == NULL) {
- return(NULL);
+ return NULL;
}
alpm_list_t *dblist = alpm_list_diff(_alpm_db_get_pkgcache(db),
@@ -200,7 +200,7 @@ alpm_list_t *_alpm_outerconflicts(pmdb_t *db, alpm_list_t *packages)
check_conflict(dblist, packages, &baddeps, -1);
alpm_list_free(dblist);
- return(baddeps);
+ return baddeps;
}
/** Check the package conflicts in a database
@@ -209,14 +209,20 @@ alpm_list_t *_alpm_outerconflicts(pmdb_t *db, alpm_list_t *packages)
* @return an alpm_list_t of pmconflict_t
*/
alpm_list_t SYMEXPORT *alpm_checkconflicts(alpm_list_t *pkglist) {
- return(_alpm_innerconflicts(pkglist));
+ return _alpm_innerconflicts(pkglist);
}
-/* Returns a alpm_list_t* of file conflicts.
- * Hooray for set-intersects!
- * 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!
+ *
+ * Operations:
+ * DIFFERENCE - a difference operation is performed. filesA - filesB.
+ * INTERSECT - an intersection operation is performed. filesA & filesB.
*/
-static alpm_list_t *chk_fileconflicts(alpm_list_t *filesA, alpm_list_t *filesB)
+static alpm_list_t *filelist_operation(alpm_list_t *filesA, alpm_list_t *filesB,
+ int operation)
{
alpm_list_t *ret = NULL;
alpm_list_t *pA = filesA, *pB = filesB;
@@ -224,7 +230,7 @@ static alpm_list_t *chk_fileconflicts(alpm_list_t *filesA, alpm_list_t *filesB)
while(pA && pB) {
const char *strA = pA->data;
const char *strB = pB->data;
- /* skip directories, we don't care about dir conflicts */
+ /* skip directories, we don't care about them */
if(strA[strlen(strA)-1] == '/') {
pA = pA->next;
} else if(strB[strlen(strB)-1] == '/') {
@@ -232,59 +238,26 @@ static alpm_list_t *chk_fileconflicts(alpm_list_t *filesA, alpm_list_t *filesB)
} else {
int cmp = strcmp(strA, strB);
if(cmp < 0) {
- /* item only in filesA, ignore it */
+ if(operation == DIFFERENCE) {
+ /* item only in filesA, qualifies as a difference */
+ ret = alpm_list_add(ret, strdup(strA));
+ }
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));
+ if(operation == INTERSECT) {
+ /* item in both, qualifies as an intersect */
+ ret = alpm_list_add(ret, strdup(strA));
+ }
pA = pA->next;
pB = pB->next;
}
}
}
- return(ret);
-}
-
-/* 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 alpm_list_t *chk_filedifference(alpm_list_t *filesA, alpm_list_t *filesB)
-{
- 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 */
- 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, record it */
- ret = alpm_list_add(ret, strdup(strA));
- pA = pA->next;
- } else if(cmp > 0) {
- /* item only in fileB, but this means nothing */
- pB = pB->next;
- } else {
- /* item in both, ignore it */
- pA = pA->next;
- pB = pB->next;
- }
- }
- }
- /* ensure we have completely emptied pA */
- while(pA) {
+ /* if doing a difference, ensure we have completely emptied pA */
+ while(operation == DIFFERENCE && pA) {
const char *strA = pA->data;
/* skip directories */
if(strA[strlen(strA)-1] != '/') {
@@ -293,7 +266,7 @@ static alpm_list_t *chk_filedifference(alpm_list_t *filesA, alpm_list_t *filesB)
pA = pA->next;
}
- return(ret);
+ return ret;
}
/* Adds pmfileconflict_t to a conflicts list. Pass the conflicts list, type (either
@@ -314,22 +287,20 @@ static alpm_list_t *add_fileconflict(alpm_list_t *conflicts,
if(name2) {
STRDUP(conflict->ctarget, name2, RET_ERR(PM_ERR_MEMORY, NULL));
} else {
- conflict->ctarget = "";
+ STRDUP(conflict->ctarget, "", RET_ERR(PM_ERR_MEMORY, NULL));
}
conflicts = alpm_list_add(conflicts, conflict);
_alpm_log(PM_LOG_DEBUG, "found file conflict %s, packages %s and %s\n",
filestr, name1, name2 ? name2 : "(filesystem)");
- return(conflicts);
+ return conflicts;
}
void _alpm_fileconflict_free(pmfileconflict_t *conflict)
{
- if(strlen(conflict->ctarget) > 0) {
- FREE(conflict->ctarget);
- }
- FREE(conflict->file);;
+ FREE(conflict->ctarget);
+ FREE(conflict->file);
FREE(conflict->target);
FREE(conflict);
}
@@ -345,7 +316,7 @@ static int dir_belongsto_pkg(char *dirpath, pmpkg_t *pkg)
snprintf(abspath, PATH_MAX, "%s%s", handle->root, dirpath);
dir = opendir(abspath);
if(dir == NULL) {
- return(1);
+ return 1;
}
while((ent = readdir(dir)) != NULL) {
const char *name = ent->d_name;
@@ -363,19 +334,19 @@ static int dir_belongsto_pkg(char *dirpath, pmpkg_t *pkg)
continue;
} else {
closedir(dir);
- return(0);
+ return 0;
}
} else {
if(alpm_list_find_str(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:
@@ -391,7 +362,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(pmdb_t *db, pmtrans_t *trans,
ALPM_LOG_FUNC;
if(db == NULL || upgrade == NULL || trans == NULL) {
- return(NULL);
+ return NULL;
}
/* TODO this whole function needs a huge change, which hopefully will
@@ -419,7 +390,8 @@ alpm_list_t *_alpm_db_find_fileconflicts(pmdb_t *db, pmtrans_t *trans,
if(!p2) {
continue;
}
- tmpfiles = chk_fileconflicts(alpm_pkg_get_files(p1), alpm_pkg_get_files(p2));
+ tmpfiles = filelist_operation( alpm_pkg_get_files(p1),
+ alpm_pkg_get_files(p2), INTERSECT);
if(tmpfiles) {
for(k = tmpfiles; k; k = k->next) {
@@ -444,8 +416,8 @@ alpm_list_t *_alpm_db_find_fileconflicts(pmdb_t *db, pmtrans_t *trans,
* is not currently installed, then simply stat the whole filelist */
if(dbpkg) {
/* older ver of package currently installed */
- tmpfiles = chk_filedifference(alpm_pkg_get_files(p1),
- alpm_pkg_get_files(dbpkg));
+ tmpfiles = filelist_operation(alpm_pkg_get_files(p1),
+ alpm_pkg_get_files(dbpkg), DIFFERENCE);
} else {
/* no version of package currently installed */
tmpfiles = alpm_list_strdup(alpm_pkg_get_files(p1));
@@ -540,7 +512,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(pmdb_t *db, pmtrans_t *trans,
PROGRESS(trans, PM_TRANS_PROGRESS_CONFLICTS_START, "", 100,
numtargs, current);
- return(conflicts);
+ return conflicts;
}
const char SYMEXPORT *alpm_conflict_get_package1(pmconflict_t *conflict)
@@ -548,8 +520,8 @@ 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));
+ ASSERT(handle != NULL, return NULL);
+ ASSERT(conflict != NULL, return NULL);
return conflict->package1;
}
@@ -559,8 +531,8 @@ 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));
+ ASSERT(handle != NULL, return NULL);
+ ASSERT(conflict != NULL, return NULL);
return conflict->package2;
}
@@ -570,8 +542,8 @@ 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));
+ ASSERT(handle != NULL, return NULL);
+ ASSERT(conflict != NULL, return NULL);
return conflict->reason;
}
@@ -581,8 +553,8 @@ 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));
+ ASSERT(handle != NULL, return NULL);
+ ASSERT(conflict != NULL, return NULL);
return conflict->target;
}
@@ -592,8 +564,8 @@ pmfileconflicttype_t SYMEXPORT alpm_fileconflict_get_type(pmfileconflict_t *conf
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(-1));
- ASSERT(conflict != NULL, return(-1));
+ ASSERT(handle != NULL, return -1);
+ ASSERT(conflict != NULL, return -1);
return conflict->type;
}
@@ -603,8 +575,8 @@ 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));
+ ASSERT(handle != NULL, return NULL);
+ ASSERT(conflict != NULL, return NULL);
return conflict->file;
}
@@ -614,8 +586,8 @@ 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));
+ ASSERT(handle != NULL, return NULL);
+ ASSERT(conflict != NULL, return NULL);
return conflict->ctarget;
}
diff --git a/lib/libalpm/db.c b/lib/libalpm/db.c
index 1a3168b4..31336144 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"
@@ -58,7 +55,7 @@ pmdb_t SYMEXPORT *alpm_db_register_sync(const char *treename)
/* Do not register a database if a transaction is on-going */
ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, NULL));
- return(_alpm_db_register_sync(treename));
+ return _alpm_db_register_sync(treename);
}
/* Helper function for alpm_db_unregister{_all} */
@@ -92,7 +89,7 @@ int SYMEXPORT alpm_db_unregister_all(void)
i->data = NULL;
}
FREELIST(handle->dbs_sync);
- return(0);
+ return 0;
}
/** Unregister a package database. */
@@ -129,49 +126,119 @@ int SYMEXPORT alpm_db_unregister(pmdb_t *db)
}
db->ops->unregister(db);
- return(0);
+ return 0;
+}
+
+/** Get the serverlist of a database. */
+alpm_list_t SYMEXPORT *alpm_db_get_servers(const pmdb_t *db)
+{
+ ALPM_LOG_FUNC;
+
+ /* Sanity checks */
+ ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, 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(pmdb_t *db, alpm_list_t *servers)
+{
+ ALPM_LOG_FUNC;
+
+ /* Sanity checks */
+ ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
+
+ if(db->servers) FREELIST(db->servers);
+ db->servers = servers;
+ return 0;
+}
+
+static char *sanitize_url(const char *url)
+{
+ char *newurl;
+ size_t len = strlen(url);
+
+ STRDUP(newurl, url, RET_ERR(PM_ERR_MEMORY, NULL));
+ /* strip the trailing slash if one exists */
+ if(newurl[len - 1] == '/') {
+ newurl[len - 1] = '\0';
+ }
+ return newurl;
+}
+
+/** 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(pmdb_t *db, const char *url)
{
- alpm_list_t *i;
- int found = 0;
char *newurl;
- size_t len = 0;
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
+ ASSERT(url != NULL && strlen(url) != 0, RET_ERR(PM_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(PM_LOG_DEBUG, "adding new server URL to database '%s': %s\n",
+ db->treename, newurl);
+
+ 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(pmdb_t *db, const char *url)
+{
+ char *newurl, *vdata = NULL;
- if(url) {
- len = strlen(url);
+ ALPM_LOG_FUNC;
+
+ /* Sanity checks */
+ ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
+ ASSERT(url != NULL && strlen(url) != 0, RET_ERR(PM_ERR_WRONG_ARGS, -1));
+
+ newurl = sanitize_url(url);
+ if(!newurl) {
+ return -1;
}
- if(len) {
- newurl = strdup(url);
- /* strip the trailing slash if one exists */
- if(newurl[len - 1] == '/') {
- newurl[len - 1] = '\0';
- }
- db->servers = alpm_list_add(db->servers, newurl);
- _alpm_log(PM_LOG_DEBUG, "adding new server URL to database '%s': %s\n",
+ db->servers = alpm_list_remove_str(db->servers, newurl, &vdata);
+ free(newurl);
+ if(vdata) {
+ _alpm_log(PM_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 1;
+}
+/** Set the verify gpg signature option for a database.
+ * @param db database pointer
+ * @param verify enum pgp_verify_t
+ * @return 0 on success, -1 on error (pm_errno is set accordingly)
+ */
+int SYMEXPORT alpm_db_set_pgp_verify(pmdb_t *db, pgp_verify_t verify)
+{
+ ALPM_LOG_FUNC;
+
+ /* Sanity checks */
+ ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
+
+ db->pgp_verify = verify;
+ _alpm_log(PM_LOG_DEBUG, "adding VerifySig option to database '%s': %d\n",
+ db->treename, verify);
+
return(0);
}
@@ -181,8 +248,8 @@ const char SYMEXPORT *alpm_db_get_name(const pmdb_t *db)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
+ ASSERT(handle != NULL, return NULL);
+ ASSERT(db != NULL, return NULL);
return db->treename;
}
@@ -195,13 +262,13 @@ const char SYMEXPORT *alpm_db_get_url(const pmdb_t *db)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
- ASSERT(db->servers != NULL, return(NULL));
+ ASSERT(handle != NULL, return NULL);
+ ASSERT(db != NULL, return NULL);
+ ASSERT(db->servers != NULL, return NULL);
- url = (char*)db->servers->data;
+ url = (char *)db->servers->data;
- return(url);
+ return url;
}
@@ -211,11 +278,11 @@ pmpkg_t SYMEXPORT *alpm_db_get_pkg(pmdb_t *db, const char *name)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
- ASSERT(name != NULL && strlen(name) != 0, return(NULL));
+ 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));
+ return _alpm_db_get_pkgfromcache(db, name);
}
/** Get the package cache of a package database. */
@@ -224,10 +291,10 @@ alpm_list_t SYMEXPORT *alpm_db_get_pkgcache(pmdb_t *db)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
+ ASSERT(handle != NULL, return NULL);
+ ASSERT(db != NULL, return NULL);
- return(_alpm_db_get_pkgcache(db));
+ return _alpm_db_get_pkgcache(db);
}
/** Get a group entry from a package database. */
@@ -236,11 +303,11 @@ pmgrp_t SYMEXPORT *alpm_db_readgrp(pmdb_t *db, const char *name)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
- ASSERT(name != NULL && strlen(name) != 0, return(NULL));
+ 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_grpfromcache(db, name);
}
/** Get the group cache of a package database. */
@@ -249,10 +316,10 @@ alpm_list_t SYMEXPORT *alpm_db_get_grpcache(pmdb_t *db)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
+ ASSERT(handle != NULL, return NULL);
+ ASSERT(db != NULL, return NULL);
- return(_alpm_db_get_grpcache(db));
+ return _alpm_db_get_grpcache(db);
}
/** Searches a database. */
@@ -261,10 +328,10 @@ alpm_list_t SYMEXPORT *alpm_db_search(pmdb_t *db, const alpm_list_t* needles)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(db != NULL, return(NULL));
+ ASSERT(handle != NULL, return NULL);
+ ASSERT(db != NULL, return NULL);
- return(_alpm_db_search(db, needles));
+ return _alpm_db_search(db, needles);
}
/** Set install reason for a package in db. */
@@ -284,7 +351,7 @@ int SYMEXPORT alpm_db_set_pkgreason(pmdb_t *db, const char *name, pmpkgreason_t
_alpm_log(PM_LOG_DEBUG, "setting install reason %u for %s/%s\n", reason, db->treename, name);
if(alpm_pkg_get_reason(pkg) == reason) {
/* we are done */
- return(0);
+ return 0;
}
/* set reason (in pkgcache) */
pkg->reason = reason;
@@ -293,7 +360,7 @@ int SYMEXPORT alpm_db_set_pkgreason(pmdb_t *db, const char *name, pmpkgreason_t
RET_ERR(PM_ERR_DB_WRITE, -1);
}
- return(0);
+ return 0;
}
/** @} */
@@ -308,7 +375,7 @@ pmdb_t *_alpm_db_new(const char *treename, int is_local)
STRDUP(db->treename, treename, RET_ERR(PM_ERR_MEMORY, NULL));
db->is_local = is_local;
- return(db);
+ return db;
}
void _alpm_db_free(pmdb_t *db)
@@ -329,7 +396,7 @@ void _alpm_db_free(pmdb_t *db)
const char *_alpm_db_path(pmdb_t *db)
{
if(!db) {
- return(NULL);
+ return NULL;
}
if(!db->_path) {
const char *dbpath;
@@ -354,22 +421,22 @@ const char *_alpm_db_path(pmdb_t *db)
_alpm_log(PM_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)
{
if(!db) {
- return(-1);
+ return -1;
}
- return(db->ops->version(db));
+ return db->ops->version(db);
}
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));
+ return strcmp(db1->treename, db2->treename);
}
alpm_list_t *_alpm_db_search(pmdb_t *db, const alpm_list_t *needles)
@@ -407,7 +474,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 +482,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 +491,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;
}
@@ -445,7 +512,7 @@ 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.
@@ -456,7 +523,7 @@ int _alpm_db_load_pkgcache(pmdb_t *db)
ALPM_LOG_FUNC;
if(db == NULL) {
- return(-1);
+ return -1;
}
_alpm_db_free_pkgcache(db);
@@ -465,11 +532,11 @@ int _alpm_db_load_pkgcache(pmdb_t *db)
if(db->ops->populate(db) == -1) {
_alpm_log(PM_LOG_DEBUG,
"failed to load package cache for repository '%s'\n", db->treename);
- return(-1);
+ return -1;
}
db->pkgcache_loaded = 1;
- return(0);
+ return 0;
}
void _alpm_db_free_pkgcache(pmdb_t *db)
@@ -496,7 +563,7 @@ pmpkghash_t *_alpm_db_get_pkgcache_hash(pmdb_t *db)
ALPM_LOG_FUNC;
if(db == NULL) {
- return(NULL);
+ return NULL;
}
if(!db->pkgcache_loaded) {
@@ -508,7 +575,7 @@ pmpkghash_t *_alpm_db_get_pkgcache_hash(pmdb_t *db)
_alpm_log(PM_LOG_DEBUG, "warning: pkgcache is NULL for db '%s'\n", db->treename);
}
- return(db->pkgcache);
+ return db->pkgcache;
}
alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db)
@@ -518,10 +585,10 @@ alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db)
pmpkghash_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 */
@@ -532,12 +599,12 @@ int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg)
ALPM_LOG_FUNC;
if(db == NULL || !db->pkgcache_loaded || pkg == NULL) {
- return(-1);
+ 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",
@@ -546,7 +613,7 @@ int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg)
_alpm_db_free_grpcache(db);
- return(0);
+ return 0;
}
int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg)
@@ -556,7 +623,7 @@ int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg)
ALPM_LOG_FUNC;
if(db == NULL || !db->pkgcache_loaded || pkg == NULL) {
- return(-1);
+ return -1;
}
_alpm_log(PM_LOG_DEBUG, "removing entry '%s' from '%s' cache\n",
@@ -567,14 +634,14 @@ int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg)
/* package not found */
_alpm_log(PM_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);
- return(0);
+ return 0;
}
pmpkg_t *_alpm_db_get_pkgfromcache(pmdb_t *db, const char *target)
@@ -582,17 +649,17 @@ pmpkg_t *_alpm_db_get_pkgfromcache(pmdb_t *db, const char *target)
ALPM_LOG_FUNC;
if(db == NULL) {
- return(NULL);
+ return NULL;
}
pmpkghash_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.
@@ -604,7 +671,7 @@ int _alpm_db_load_grpcache(pmdb_t *db)
ALPM_LOG_FUNC;
if(db == NULL) {
- return(-1);
+ return -1;
}
_alpm_log(PM_LOG_DEBUG, "loading group cache for repository '%s'\n",
@@ -642,7 +709,7 @@ int _alpm_db_load_grpcache(pmdb_t *db)
}
db->grpcache_loaded = 1;
- return(0);
+ return 0;
}
void _alpm_db_free_grpcache(pmdb_t *db)
@@ -671,14 +738,14 @@ alpm_list_t *_alpm_db_get_grpcache(pmdb_t *db)
ALPM_LOG_FUNC;
if(db == NULL) {
- return(NULL);
+ return NULL;
}
if(!db->grpcache_loaded) {
_alpm_db_load_grpcache(db);
}
- return(db->grpcache);
+ return db->grpcache;
}
pmgrp_t *_alpm_db_get_grpfromcache(pmdb_t *db, const char *target)
@@ -688,18 +755,18 @@ pmgrp_t *_alpm_db_get_grpfromcache(pmdb_t *db, const char *target)
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;
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..399e2d56 100644
--- a/lib/libalpm/db.h
+++ b/lib/libalpm/db.h
@@ -31,6 +31,9 @@
#include <archive.h>
#include <archive_entry.h>
+#include "alpm.h"
+#include "signing.h"
+
/* Database entries */
typedef enum _pmdbinfrq_t {
INFRQ_BASE = 1,
@@ -60,6 +63,7 @@ struct __pmdb_t {
pmpkghash_t *pkgcache;
alpm_list_t *grpcache;
alpm_list_t *servers;
+ pgp_verify_t pgp_verify;
struct db_operations *ops;
};
diff --git a/lib/libalpm/delta.c b/lib/libalpm/delta.c
index 10c982f2..d3213fd1 100644
--- a/lib/libalpm/delta.c
+++ b/lib/libalpm/delta.c
@@ -41,32 +41,32 @@
const char SYMEXPORT *alpm_delta_get_from(pmdelta_t *delta)
{
- ASSERT(delta != NULL, return(NULL));
- return(delta->from);
+ 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);
+ 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);
+ 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);
+ 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);
+ ASSERT(delta != NULL, return -1);
+ return delta->delta_size;
}
/** @} */
@@ -108,7 +108,7 @@ 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)
@@ -205,7 +205,7 @@ static off_t shortest_path(alpm_list_t *vertices, const char *to, alpm_list_t **
*path = alpm_list_reverse(rpath);
alpm_list_free(rpath);
- return(bestsize);
+ return bestsize;
}
/** Calculates the shortest path from one version to another.
@@ -229,7 +229,7 @@ off_t _alpm_shortest_delta_path(alpm_list_t *deltas,
if(deltas == NULL) {
*path = NULL;
- return(bestsize);
+ return bestsize;
}
_alpm_log(PM_LOG_DEBUG, "started delta shortest-path search for '%s'\n", to);
@@ -245,7 +245,7 @@ off_t _alpm_shortest_delta_path(alpm_list_t *deltas,
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)
@@ -273,7 +273,7 @@ static alpm_list_t *find_unused(alpm_list_t *deltas, const char *to, off_t quota
}
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)
@@ -283,7 +283,7 @@ alpm_list_t SYMEXPORT *alpm_pkg_unused_deltas(pmpkg_t *pkg)
alpm_pkg_get_deltas(pkg),
alpm_pkg_get_filename(pkg),
pkgsize * MAX_DELTA_RATIO);
- return(unused);
+ return unused;
}
@@ -308,7 +308,7 @@ 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);
@@ -339,7 +339,7 @@ pmdelta_t *_alpm_delta_parse(char *line)
_alpm_log(PM_LOG_DEBUG, "delta : %s %s '%jd'\n", delta->from, delta->to, (intmax_t)delta->delta_size);
- return(delta);
+ return delta;
}
void _alpm_delta_free(pmdelta_t *delta)
diff --git a/lib/libalpm/delta.h b/lib/libalpm/delta.h
index d7a81c47..bd196bab 100644
--- a/lib/libalpm/delta.h
+++ b/lib/libalpm/delta.h
@@ -20,6 +20,8 @@
#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"
@@ -29,12 +31,12 @@ struct __pmdelta_t {
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;
+ /** filesize of the delta file */
+ off_t delta_size;
/** download filesize of the delta file */
off_t download_size;
};
diff --git a/lib/libalpm/deps.c b/lib/libalpm/deps.c
index 36d6e1aa..c5fb92ef 100644
--- a/lib/libalpm/deps.c
+++ b/lib/libalpm/deps.c
@@ -56,7 +56,7 @@ static pmdepmissing_t *depmiss_new(const char *target, pmdepend_t *dep,
miss->depend = _alpm_dep_dup(dep);
STRDUP(miss->causingpkg, causingpkg, RET_ERR(PM_ERR_MEMORY, NULL));
- return(miss);
+ return miss;
}
void _alpm_depmiss_free(pmdepmissing_t *miss)
@@ -73,10 +73,10 @@ static int _alpm_dep_edge(pmpkg_t *pkg1, pmpkg_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,
@@ -110,7 +110,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.
@@ -137,7 +137,7 @@ alpm_list_t *_alpm_sortbydeps(alpm_list_t *targets, int reverse)
ALPM_LOG_FUNC;
if(targets == NULL) {
- return(NULL);
+ return NULL;
}
_alpm_log(PM_LOG_DEBUG, "started sorting dependencies\n");
@@ -153,7 +153,7 @@ alpm_list_t *_alpm_sortbydeps(alpm_list_t *targets, int reverse)
while(vertex->childptr && !found) {
pmgraph_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;
@@ -181,7 +181,7 @@ 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;
}
}
@@ -201,7 +201,7 @@ 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)
@@ -214,7 +214,7 @@ static pmdepend_t *filtered_depend(pmdepend_t *dep, int nodepversion)
{
if(nodepversion) {
pmdepend_t *newdep = _alpm_dep_dup(dep);
- ASSERT(newdep, return(dep));
+ ASSERT(newdep, return dep);
newdep->mod = PM_DEP_MOD_ANY;
dep = newdep;
}
@@ -235,10 +235,10 @@ static pmpkg_t *find_dep_satisfier(alpm_list_t *pkgs, pmdepend_t *dep)
for(i = pkgs; i; i = alpm_list_next(i)) {
pmpkg_t *pkg = i->data;
if(_alpm_depcmp(pkg, dep)) {
- return(pkg);
+ return pkg;
}
}
- return(NULL);
+ return NULL;
}
/** Find a package satisfying a specified dependency.
@@ -252,7 +252,7 @@ pmpkg_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_dep_free(dep);
- return(pkg);
+ return pkg;
}
/** Checks dependencies and returns missing ones in a list.
@@ -343,7 +343,7 @@ 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,
@@ -364,7 +364,7 @@ static int dep_vercmp(const char *version1, pmdepmod_t mod,
default: equal = 1; break;
}
}
- return(equal);
+ return equal;
}
int _alpm_depcmp(pmpkg_t *pkg, pmdepend_t *dep)
@@ -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;
}
}
@@ -406,7 +406,7 @@ int _alpm_depcmp(pmpkg_t *pkg, pmdepend_t *dep)
}
}
- return(satisfy);
+ return satisfy;
}
pmdepend_t *_alpm_splitdep(const char *depstring)
@@ -415,7 +415,7 @@ pmdepend_t *_alpm_splitdep(const char *depstring)
const char *ptr, *version = NULL;
if(depstring == NULL) {
- return(NULL);
+ return NULL;
}
CALLOC(depend, 1, sizeof(pmdepend_t), RET_ERR(PM_ERR_MEMORY, NULL));
@@ -451,7 +451,7 @@ pmdepend_t *_alpm_splitdep(const char *depstring)
STRDUP(depend->version, version, RET_ERR(PM_ERR_MEMORY, NULL));
}
- return(depend);
+ return depend;
}
pmdepend_t *_alpm_dep_dup(const pmdepend_t *dep)
@@ -464,7 +464,7 @@ pmdepend_t *_alpm_dep_dup(const pmdepend_t *dep)
STRDUP(newdep->version, dep->version, RET_ERR(PM_ERR_MEMORY, NULL));
newdep->mod = dep->mod;
- return(newdep);
+ return newdep;
}
/* These parameters are messy. We check if this package, given a list of
@@ -477,7 +477,7 @@ static int can_remove_package(pmdb_t *db, pmpkg_t *pkg, alpm_list_t *targets,
alpm_list_t *i;
if(_alpm_pkg_find(targets, alpm_pkg_get_name(pkg))) {
- return(0);
+ return 0;
}
if(!include_explicit) {
@@ -485,7 +485,7 @@ static int can_remove_package(pmdb_t *db, pmpkg_t *pkg, alpm_list_t *targets,
if(alpm_pkg_get_reason(pkg) == PM_PKG_REASON_EXPLICIT) {
_alpm_log(PM_LOG_DEBUG, "excluding %s -- explicitly installed\n",
alpm_pkg_get_name(pkg));
- return(0);
+ return 0;
}
}
@@ -499,12 +499,12 @@ static int can_remove_package(pmdb_t *db, pmpkg_t *pkg, alpm_list_t *targets,
for(i = _alpm_db_get_pkgcache(db); i; i = i->next) {
pmpkg_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;
}
/**
@@ -569,7 +569,7 @@ static pmpkg_t *resolvedep(pmdepend_t *dep, alpm_list_t *dbs,
if(pkg && _alpm_depcmp(pkg, dep) && !_alpm_pkg_find(excluding, pkg->name)) {
if(_alpm_pkg_should_ignore(pkg)) {
int install = 0;
- if (prompt) {
+ if(prompt) {
QUESTION(handle->trans, PM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
NULL, NULL, &install);
} else {
@@ -580,7 +580,7 @@ static pmpkg_t *resolvedep(pmdepend_t *dep, alpm_list_t *dbs,
continue;
}
}
- return(pkg);
+ return pkg;
}
}
/* 2. satisfiers (skip literals here) */
@@ -591,7 +591,7 @@ static pmpkg_t *resolvedep(pmdepend_t *dep, alpm_list_t *dbs,
!_alpm_pkg_find(excluding, pkg->name)) {
if(_alpm_pkg_should_ignore(pkg)) {
int install = 0;
- if (prompt) {
+ if(prompt) {
QUESTION(handle->trans, PM_TRANS_CONV_INSTALL_IGNOREPKG,
pkg, NULL, NULL, &install);
} else {
@@ -613,13 +613,13 @@ 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)) {
+ 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) {
@@ -630,7 +630,7 @@ static pmpkg_t *resolvedep(pmdepend_t *dep, alpm_list_t *dbs,
if(index >= 0 && index < count) {
pmpkg_t *pkg = alpm_list_getdata(alpm_list_nth(providers, index));
alpm_list_free(providers);
- return(pkg);
+ return pkg;
}
alpm_list_free(providers);
providers = NULL;
@@ -641,7 +641,7 @@ static pmpkg_t *resolvedep(pmdepend_t *dep, alpm_list_t *dbs,
} else {
pm_errno = PM_ERR_PKG_NOT_FOUND;
}
- return(NULL);
+ return NULL;
}
/** Find a package satisfying a specified dependency.
@@ -657,13 +657,13 @@ pmpkg_t SYMEXPORT *alpm_find_dbs_satisfier(alpm_list_t *dbs, const char *depstri
pmdepend_t *dep;
pmpkg_t *pkg;
- ASSERT(dbs, return(NULL));
+ ASSERT(dbs, return NULL);
dep = _alpm_splitdep(depstring);
- ASSERT(dep, return(NULL));
+ ASSERT(dep, return NULL);
pkg = resolvedep(dep, dbs, NULL, 1);
_alpm_dep_free(dep);
- return(pkg);
+ return pkg;
}
/**
@@ -699,7 +699,7 @@ int _alpm_resolvedeps(alpm_list_t *localpkgs, alpm_list_t *dbs_sync, pmpkg_t *pk
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
@@ -760,7 +760,7 @@ int _alpm_resolvedeps(alpm_list_t *localpkgs, alpm_list_t *dbs_sync, pmpkg_t *pk
alpm_list_free(packages_copy);
}
_alpm_log(PM_LOG_DEBUG, "finished resolving dependencies\n");
- return(ret);
+ return ret;
}
const char SYMEXPORT *alpm_miss_get_target(const pmdepmissing_t *miss)
@@ -768,9 +768,9 @@ const char SYMEXPORT *alpm_miss_get_target(const pmdepmissing_t *miss)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(miss != NULL, return(NULL));
+ ASSERT(miss != NULL, return NULL);
- return(miss->target);
+ return miss->target;
}
const char SYMEXPORT *alpm_miss_get_causingpkg(const pmdepmissing_t *miss)
@@ -778,7 +778,7 @@ const char SYMEXPORT *alpm_miss_get_causingpkg(const pmdepmissing_t *miss)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(miss != NULL, return(NULL));
+ ASSERT(miss != NULL, return NULL);
return miss->causingpkg;
}
@@ -788,9 +788,9 @@ pmdepend_t SYMEXPORT *alpm_miss_get_dep(pmdepmissing_t *miss)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(miss != NULL, return(NULL));
+ ASSERT(miss != NULL, return NULL);
- return(miss->depend);
+ return miss->depend;
}
pmdepmod_t SYMEXPORT alpm_dep_get_mod(const pmdepend_t *dep)
@@ -798,9 +798,9 @@ pmdepmod_t SYMEXPORT alpm_dep_get_mod(const pmdepend_t *dep)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(dep != NULL, return(-1));
+ ASSERT(dep != NULL, return -1);
- return(dep->mod);
+ return dep->mod;
}
const char SYMEXPORT *alpm_dep_get_name(const pmdepend_t *dep)
@@ -808,9 +808,9 @@ const char SYMEXPORT *alpm_dep_get_name(const pmdepend_t *dep)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(dep != NULL, return(NULL));
+ ASSERT(dep != NULL, return NULL);
- return(dep->name);
+ return dep->name;
}
const char SYMEXPORT *alpm_dep_get_version(const pmdepend_t *dep)
@@ -818,9 +818,9 @@ const char SYMEXPORT *alpm_dep_get_version(const pmdepend_t *dep)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(dep != NULL, return(NULL));
+ ASSERT(dep != NULL, return NULL);
- return(dep->version);
+ return dep->version;
}
/** Reverse of splitdep; make a dep string from a pmdepend_t struct.
@@ -837,7 +837,7 @@ char SYMEXPORT *alpm_dep_compute_string(const pmdepend_t *dep)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(dep != NULL, return(NULL));
+ ASSERT(dep != NULL, return NULL);
if(dep->name) {
name = dep->name;
@@ -882,6 +882,6 @@ char SYMEXPORT *alpm_dep_compute_string(const pmdepend_t *dep)
MALLOC(str, len, RET_ERR(PM_ERR_MEMORY, 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/diskspace.c b/lib/libalpm/diskspace.c
index 066107d7..102b42c6 100644
--- a/lib/libalpm/diskspace.c
+++ b/lib/libalpm/diskspace.c
@@ -56,7 +56,7 @@ 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)
@@ -71,8 +71,8 @@ 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))) {
@@ -103,8 +103,8 @@ 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++) {
@@ -128,7 +128,7 @@ static alpm_list_t *mount_point_list(void)
mp = ptr->data;
_alpm_log(PM_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,12 +140,12 @@ 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,
@@ -182,7 +182,7 @@ 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,
@@ -192,7 +192,7 @@ static int calculate_installed_size(const alpm_list_t *mount_points,
struct archive *archive;
struct archive_entry *entry;
- if ((archive = archive_read_new()) == NULL) {
+ if((archive = archive_read_new()) == NULL) {
pm_errno = PM_ERR_LIBARCHIVE;
ret = -1;
goto cleanup;
@@ -254,7 +254,7 @@ static int calculate_installed_size(const alpm_list_t *mount_points,
archive_read_finish(archive);
cleanup:
- return(ret);
+ return ret;
}
int _alpm_check_diskspace(pmtrans_t *trans, pmdb_t *db_local)
@@ -269,13 +269,13 @@ int _alpm_check_diskspace(pmtrans_t *trans, pmdb_t *db_local)
mount_points = mount_point_list();
if(mount_points == NULL) {
_alpm_log(PM_LOG_ERROR, _("could not determine filesystem mount points\n"));
- return(-1);
+ 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"),
handle->root);
- return(-1);
+ return -1;
}
replaces = alpm_list_count(trans->remove);
@@ -352,7 +352,7 @@ int _alpm_check_diskspace(pmtrans_t *trans, pmdb_t *db_local)
RET_ERR(PM_ERR_DISK_SPACE, -1);
}
- return(0);
+ return 0;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/dload.c b/lib/libalpm/dload.c
index a98d84ac..1825eed5 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,184 @@
#include "util.h"
#include "handle.h"
-static char *get_filename(const char *url) {
+#ifdef HAVE_LIBCURL
+static double prevprogress; /* last download amount */
+#endif
+
+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 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), RET_ERR(PM_ERR_MEMORY, NULL));
+ snprintf(filepath, len, "%s%s%s", path, filename, suffix);
- return(destfile);
+ 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 fileinfo *dlfile = (struct fileinfo *)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(handle->dlcb == NULL) {
+ return 0;
+ }
+
+ current_size = dlfile->initial_size + dlnow;
+ total_size = dlfile->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)) {
+ handle->dlcb(dlfile->filename, 0, (long)dltotal);
}
- return(host);
+
+ handle->dlcb(dlfile->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 */
+ _alpm_log(PM_LOG_ERROR, _("buffer overflow detected"));
+ 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 time)
+{
+ if(time != -1) {
+ struct timeval tv[2];
+ memset(&tv, 0, sizeof(tv));
+ tv[0].tv_sec = tv[1].tv_sec = time;
+ return utimes(path, tv);
+ }
+ return 0;
+}
-static int download_internal(const char *url, const char *localpath,
- int force) {
+
+static int curl_download_internal(const char *url, const char *localpath,
+ int force, int allow_resume, int errors_ok)
+{
+ int ret = -1;
FILE *localf = NULL;
+ const char *useragent;
+ const char *open_mode = "wb";
+ char *destfile, *tempfile;
+ /* 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;
+ double remote_size, bytes_dl;
struct sigaction sig_pipe[2], sig_int[2];
+ struct fileinfo dlfile;
- 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];
-
- filename = get_filename(url);
- if(!filename) {
+ dlfile.initial_size = 0.0;
+ dlfile.filename = get_filename(url);
+ if(!dlfile.filename || curl_gethost(url, hostname) != 0) {
_alpm_log(PM_LOG_ERROR, _("url '%s' is invalid\n"), url);
RET_ERR(PM_ERR_SERVER_BAD_URL, -1);
}
- fileurl = fetchParseURL(url);
- if(!fileurl) {
- _alpm_log(PM_LOG_ERROR, _("url '%s' is invalid\n"), url);
- RET_ERR(PM_ERR_LIBFETCH, -1);
+ destfile = get_fullpath(localpath, dlfile.filename, "");
+ tempfile = get_fullpath(localpath, dlfile.filename, ".part");
+ if(!destfile || !tempfile) {
+ goto cleanup;
}
- 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");
+ 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, url);
+ 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 *)&dlfile);
+ curl_easy_setopt(handle->curl, CURLOPT_LOW_SPEED_LIMIT, 1024L);
+ curl_easy_setopt(handle->curl, CURLOPT_LOW_SPEED_TIME, 10L);
+
+ 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(!allow_resume && !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 && 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(PM_LOG_DEBUG, "tempfile found, attempting continuation");
+ dlfile.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"));
+ 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,168 +236,67 @@ 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;
- 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;
- 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;
- }
+ /* Progress 0 - initialize */
+ prevprogress = 0;
- fetchLastErrCode = 0;
- dlf = fetchGet(fileurl, "");
- check_stop();
+ /* perform transfer */
+ handle->curlerr = curl_easy_perform(handle->curl);
- 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;
+ /* was it a success? */
+ if(handle->curlerr == CURLE_ABORTED_BY_CALLBACK) {
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);
- }
-
-
- 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;
+ } else if(handle->curlerr != CURLE_OK) {
+ if(!errors_ok) {
+ pm_errno = PM_ERR_LIBCURL;
+ _alpm_log(PM_LOG_ERROR, _("failed retrieving file '%s' from %s : %s\n"),
+ dlfile.filename, hostname, error_buffer);
+ } else {
+ _alpm_log(PM_LOG_DEBUG, "failed retrieving file '%s' from %s : %s\n",
+ dlfile.filename, hostname, error_buffer);
}
+ unlink(tempfile);
+ goto cleanup;
}
- /* Progress 0 - initialize */
- if(handle->dlcb) {
- handle->dlcb(filename, 0, ust.size);
- }
-
- 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));
- ret = -1;
- goto cleanup;
- }
- dl_thisfile += nread;
-
- if(handle->dlcb) {
- handle->dlcb(filename, dl_thisfile, ust.size);
- }
- }
+ /* 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);
- /* 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;
+ /* 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;
}
- if (ust.size != -1 && dl_thisfile < ust.size) {
+ /* 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)) {
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;
+ dlfile.filename, (intmax_t)bytes_dl, (intmax_t)remote_size);
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;
- }
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);
+ utimes_long(tempfile, remote_time);
}
- if(dlf != NULL) {
- fetchIO_close(dlf);
+
+ if(ret == 0) {
+ rename(tempfile, destfile);
}
- fetchFreeURL(fileurl);
+
+ FREE(tempfile);
+ FREE(destfile);
/* restore the old signal handlers */
sigaction(SIGINT, &sig_int[OLD], NULL);
@@ -340,86 +306,33 @@ cleanup:
raise(SIGINT);
}
- return(ret);
+ return ret;
}
#endif
-static int download(const char *url, const char *localpath,
- int force) {
+int _alpm_download(const char *url, const char *localpath,
+ int force, int allow_resume, int errors_ok)
+{
if(handle->fetchcb == NULL) {
-#ifdef HAVE_LIBFETCH
- return(download_internal(url, localpath, force));
+#ifdef HAVE_LIBCURL
+ return curl_download_internal(url, localpath, force, allow_resume, errors_ok);
#else
RET_ERR(PM_ERR_EXTERNAL_DOWNLOAD, -1);
#endif
} else {
int ret = handle->fetchcb(url, localpath, force);
- if(ret == -1) {
+ if(ret == -1 && !errors_ok) {
RET_ERR(PM_ERR_EXTERNAL_DOWNLOAD, -1);
}
- 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)
-{
- alpm_list_t *i;
- int ret = -1;
-
- ASSERT(servers != NULL, RET_ERR(PM_ERR_SERVER_NONE, -1));
-
- for(i = servers; i; i = i->next) {
- const char *server = i->data;
- char *fileurl = NULL;
- size_t len;
-
- /* 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);
-
- ret = download(fileurl, localpath, force);
- FREE(fileurl);
- if(ret != -1) {
- break;
- }
- }
-
- 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++;
- }
+ return ret;
}
-
- return(ret);
}
/** Fetch a remote pkg. */
char SYMEXPORT *alpm_fetch_pkgurl(const char *url)
{
- char *filename, *filepath;
- const char *cachedir;
+ char *filepath;
+ const char *filename, *cachedir;
int ret;
ALPM_LOG_FUNC;
@@ -430,16 +343,38 @@ char SYMEXPORT *alpm_fetch_pkgurl(const char *url)
cachedir = _alpm_filecache_setup();
/* download the file */
- ret = download(url, cachedir, 0);
+ ret = _alpm_download(url, cachedir, 0, 1, 0);
if(ret == -1) {
_alpm_log(PM_LOG_WARNING, _("failed to download %s\n"), url);
- return(NULL);
+ return NULL;
}
_alpm_log(PM_LOG_DEBUG, "successfully downloaded %s\n", url);
+ /* attempt to download the signature */
+ if(ret == 0 && (handle->sigverify == PM_PGP_VERIFY_ALWAYS ||
+ handle->sigverify == PM_PGP_VERIFY_OPTIONAL)) {
+ char *sig_url;
+ size_t len;
+ int errors_ok = (handle->sigverify == PM_PGP_VERIFY_OPTIONAL);
+
+ len = strlen(url) + 5;
+ CALLOC(sig_url, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, NULL));
+ snprintf(sig_url, len, "%s.sig", url);
+
+ ret = _alpm_download(sig_url, cachedir, 1, 0, errors_ok);
+ if(ret == -1 && !errors_ok) {
+ _alpm_log(PM_LOG_WARNING, _("failed to download %s\n"), sig_url);
+ /* Warn now, but don't return NULL. We will fail later during package
+ * load time. */
+ } else if(ret == 0) {
+ _alpm_log(PM_LOG_DEBUG, "successfully downloaded %s\n", sig_url);
+ }
+ FREE(sig_url);
+ }
+
/* we should be able to find the file the second time around */
filepath = _alpm_filecache_find(filename);
- return(filepath);
+ return filepath;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/dload.h b/lib/libalpm/dload.h
index 63266491..f4fd14cd 100644
--- a/lib/libalpm/dload.h
+++ b/lib/libalpm/dload.h
@@ -25,14 +25,14 @@
#include <time.h>
-#define PM_DLBUF_LEN (1024 * 16)
+/* internal structure for communicating with curl progress callback */
+struct fileinfo {
+ const char *filename;
+ double initial_size;
+};
-int _alpm_download_single_file(const char *filename,
- alpm_list_t *servers, const char *localpath,
- int force);
-
-int _alpm_download_files(alpm_list_t *files,
- alpm_list_t *servers, const char *localpath);
+int _alpm_download(const char *url, const char *localpath,
+ int force, int allow_resume, int errors_ok);
#endif /* _ALPM_DLOAD_H */
diff --git a/lib/libalpm/error.c b/lib/libalpm/error.c
index 21fbb48f..4d4a065c 100644
--- a/lib/libalpm/error.c
+++ b/lib/libalpm/error.c
@@ -20,21 +20,14 @@
#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)
{
@@ -122,6 +115,13 @@ const char SYMEXPORT *alpm_strerror(int err)
return _("package architecture is not valid");
case PM_ERR_PKG_REPO_NOT_FOUND:
return _("could not find repository for target");
+ /* Signatures */
+ case PM_ERR_SIG_MISSINGDIR:
+ return _("signature directory not configured correctly");
+ case PM_ERR_SIG_INVALID:
+ return _("invalid PGP signature");
+ case PM_ERR_SIG_UNKNOWN:
+ return _("unknown PGP signature");
/* Deltas */
case PM_ERR_DLT_INVALID:
return _("invalid or corrupted delta");
@@ -147,13 +147,15 @@ const char SYMEXPORT *alpm_strerror(int err)
* 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;
+ case PM_ERR_LIBCURL:
+#ifdef HAVE_LIBCURL
+ return curl_easy_strerror(handle->curlerr);
#else
/* obviously shouldn't get here... */
return _("download library error");
#endif
+ case PM_ERR_GPGME:
+ return _("gpgme error");
case PM_ERR_EXTERNAL_DOWNLOAD:
return _("error invoking external downloader");
/* Unknown error! */
diff --git a/lib/libalpm/graph.c b/lib/libalpm/graph.c
new file mode 100644
index 00000000..2e2ba236
--- /dev/null
+++ b/lib/libalpm/graph.c
@@ -0,0 +1,52 @@
+/*
+ * 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"
+
+pmgraph_t *_alpm_graph_new(void)
+{
+ pmgraph_t *graph = NULL;
+
+ CALLOC(graph, 1, sizeof(pmgraph_t), RET_ERR(PM_ERR_MEMORY, NULL));
+ return graph;
+}
+
+void _alpm_graph_free(void *data)
+{
+ pmgraph_t *graph = data;
+ /* make my children forget about me */
+ for(alpm_list_t *i = graph->children; i; i = i->next) {
+ pmgraph_t *child = i->data;
+ child->parent = NULL;
+ }
+ alpm_list_free(graph->children);
+ /* and make my parents forget about me too */
+ if(graph->parent) {
+ alpm_list_t *me = alpm_list_find_ptr(graph->parent->children, &data);
+ graph->parent->children = alpm_list_remove_item(graph->parent->children,
+ me);
+ }
+ free(graph);
+}
+
+/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/graph.h b/lib/libalpm/graph.h
index 07986f66..f76c6004 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 __pmgraph_t {
char state; /* 0: untouched, -1: entered, other: leaving time */
- void *data;
off_t weight; /* weight of the node */
+ void *data;
struct __pmgraph_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;
+} pmgraph_t;
- CALLOC(graph, 1, sizeof(pmgraph_t), RET_ERR(PM_ERR_MEMORY, NULL));
- return(graph);
-}
+pmgraph_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..dbcc7554 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 */
@@ -40,7 +39,7 @@ pmgrp_t *_alpm_grp_new(const char *name)
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)
@@ -62,7 +61,7 @@ const char SYMEXPORT *alpm_grp_get_name(const pmgrp_t *grp)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(grp != NULL, return(NULL));
+ ASSERT(grp != NULL, return NULL);
return grp->name;
}
@@ -72,7 +71,7 @@ alpm_list_t SYMEXPORT *alpm_grp_get_pkgs(const pmgrp_t *grp)
ALPM_LOG_FUNC;
/* Sanity checks */
- ASSERT(grp != NULL, return(NULL));
+ ASSERT(grp != NULL, return NULL);
return grp->packages;
}
diff --git a/lib/libalpm/handle.c b/lib/libalpm/handle.c
index 586aad1e..39b3b600 100644
--- a/lib/libalpm/handle.c
+++ b/lib/libalpm/handle.c
@@ -27,9 +27,7 @@
#include <limits.h>
#include <sys/types.h>
#include <syslog.h>
-#include <time.h>
#include <sys/stat.h>
-#include <errno.h>
/* libalpm */
#include "handle.h"
@@ -48,7 +46,9 @@ pmhandle_t *_alpm_handle_new()
CALLOC(handle, 1, sizeof(pmhandle_t), RET_ERR(PM_ERR_MEMORY, NULL));
- return(handle);
+ handle->sigverify = PM_PGP_VERIFY_OPTIONAL;
+
+ return handle;
}
void _alpm_handle_free(pmhandle_t *handle)
@@ -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,17 +82,19 @@ void _alpm_handle_free(pmhandle_t *handle)
FREE(handle->logfile);
FREE(handle->lockfile);
FREE(handle->arch);
+ FREE(handle->signaturedir);
FREELIST(handle->dbs_sync);
FREELIST(handle->noupgrade);
FREELIST(handle->noextract);
FREELIST(handle->ignorepkg);
FREELIST(handle->ignoregrp);
FREE(handle);
+
}
alpm_cb_log SYMEXPORT alpm_option_get_logcb()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -96,7 +103,7 @@ alpm_cb_log SYMEXPORT alpm_option_get_logcb()
alpm_cb_download SYMEXPORT alpm_option_get_dlcb()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -105,7 +112,7 @@ alpm_cb_download SYMEXPORT alpm_option_get_dlcb()
alpm_cb_fetch SYMEXPORT alpm_option_get_fetchcb()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -114,7 +121,7 @@ alpm_cb_fetch SYMEXPORT alpm_option_get_fetchcb()
alpm_cb_totaldl SYMEXPORT alpm_option_get_totaldlcb()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -123,7 +130,7 @@ alpm_cb_totaldl SYMEXPORT alpm_option_get_totaldlcb()
const char SYMEXPORT *alpm_option_get_root()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -132,7 +139,7 @@ const char SYMEXPORT *alpm_option_get_root()
const char SYMEXPORT *alpm_option_get_dbpath()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -141,7 +148,7 @@ const char SYMEXPORT *alpm_option_get_dbpath()
alpm_list_t SYMEXPORT *alpm_option_get_cachedirs()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -150,7 +157,7 @@ alpm_list_t SYMEXPORT *alpm_option_get_cachedirs()
const char SYMEXPORT *alpm_option_get_logfile()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -159,16 +166,25 @@ const char SYMEXPORT *alpm_option_get_logfile()
const char SYMEXPORT *alpm_option_get_lockfile()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
return handle->lockfile;
}
+const char SYMEXPORT *alpm_option_get_signaturedir()
+{
+ if(handle == NULL) {
+ pm_errno = PM_ERR_HANDLE_NULL;
+ return NULL;
+ }
+ return handle->signaturedir;
+}
+
int SYMEXPORT alpm_option_get_usesyslog()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return -1;
}
@@ -177,7 +193,7 @@ int SYMEXPORT alpm_option_get_usesyslog()
alpm_list_t SYMEXPORT *alpm_option_get_noupgrades()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -186,7 +202,7 @@ alpm_list_t SYMEXPORT *alpm_option_get_noupgrades()
alpm_list_t SYMEXPORT *alpm_option_get_noextracts()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -195,7 +211,7 @@ alpm_list_t SYMEXPORT *alpm_option_get_noextracts()
alpm_list_t SYMEXPORT *alpm_option_get_ignorepkgs()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -204,7 +220,7 @@ alpm_list_t SYMEXPORT *alpm_option_get_ignorepkgs()
alpm_list_t SYMEXPORT *alpm_option_get_ignoregrps()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -213,7 +229,7 @@ alpm_list_t SYMEXPORT *alpm_option_get_ignoregrps()
const char SYMEXPORT *alpm_option_get_arch()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -222,7 +238,7 @@ const char SYMEXPORT *alpm_option_get_arch()
int SYMEXPORT alpm_option_get_usedelta()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return -1;
}
@@ -231,7 +247,7 @@ int SYMEXPORT alpm_option_get_usedelta()
int SYMEXPORT alpm_option_get_checkspace()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return -1;
}
@@ -240,7 +256,7 @@ int SYMEXPORT alpm_option_get_checkspace()
pmdb_t SYMEXPORT *alpm_option_get_localdb()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
@@ -249,47 +265,39 @@ pmdb_t SYMEXPORT *alpm_option_get_localdb()
alpm_list_t SYMEXPORT *alpm_option_get_syncdbs()
{
- if (handle == NULL) {
+ if(handle == NULL) {
pm_errno = PM_ERR_HANDLE_NULL;
return NULL;
}
return handle->dbs_sync;
}
-void SYMEXPORT alpm_option_set_logcb(alpm_cb_log cb)
+int SYMEXPORT alpm_option_set_logcb(alpm_cb_log cb)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return;
- }
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
handle->logcb = cb;
+ return 0;
}
-void SYMEXPORT alpm_option_set_dlcb(alpm_cb_download cb)
+int SYMEXPORT alpm_option_set_dlcb(alpm_cb_download cb)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return;
- }
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
handle->dlcb = cb;
+ return 0;
}
-void SYMEXPORT alpm_option_set_fetchcb(alpm_cb_fetch cb)
+int SYMEXPORT alpm_option_set_fetchcb(alpm_cb_fetch cb)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return;
- }
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
handle->fetchcb = cb;
+ return 0;
}
-void SYMEXPORT alpm_option_set_totaldlcb(alpm_cb_totaldl cb)
+int SYMEXPORT alpm_option_set_totaldlcb(alpm_cb_totaldl cb)
{
- if (handle == NULL) {
- pm_errno = PM_ERR_HANDLE_NULL;
- return;
- }
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
handle->totaldlcb = cb;
+ return 0;
}
int SYMEXPORT alpm_option_set_root(const char *root)
@@ -304,18 +312,18 @@ int SYMEXPORT alpm_option_set_root(const char *root)
if(!root) {
pm_errno = PM_ERR_WRONG_ARGS;
- return(-1);
+ return -1;
}
if(stat(root, &st) == -1 || !S_ISDIR(st.st_mode)) {
pm_errno = PM_ERR_NOT_A_DIR;
- return(-1);
+ return -1;
}
realroot = calloc(PATH_MAX+1, sizeof(char));
if(!realpath(root, realroot)) {
FREE(realroot);
pm_errno = PM_ERR_NOT_A_DIR;
- return(-1);
+ return -1;
}
/* verify root ends in a '/' */
@@ -331,7 +339,7 @@ int SYMEXPORT alpm_option_set_root(const char *root)
handle->root[rootlen-1] = '/';
FREE(realroot);
_alpm_log(PM_LOG_DEBUG, "option 'root' = %s\n", handle->root);
- return(0);
+ return 0;
}
int SYMEXPORT alpm_option_set_dbpath(const char *dbpath)
@@ -345,11 +353,11 @@ int SYMEXPORT alpm_option_set_dbpath(const char *dbpath)
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
if(!dbpath) {
pm_errno = PM_ERR_WRONG_ARGS;
- return(-1);
+ return -1;
}
if(stat(dbpath, &st) == -1 || !S_ISDIR(st.st_mode)) {
pm_errno = PM_ERR_NOT_A_DIR;
- return(-1);
+ return -1;
}
/* verify dbpath ends in a '/' */
dbpathlen = strlen(dbpath);
@@ -371,7 +379,7 @@ int SYMEXPORT alpm_option_set_dbpath(const char *dbpath)
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);
+ return 0;
}
int SYMEXPORT alpm_option_add_cachedir(const char *cachedir)
@@ -384,7 +392,7 @@ int SYMEXPORT alpm_option_add_cachedir(const char *cachedir)
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
if(!cachedir) {
pm_errno = PM_ERR_WRONG_ARGS;
- return(-1);
+ return -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. */
@@ -399,14 +407,15 @@ int SYMEXPORT alpm_option_add_cachedir(const char *cachedir)
newcachedir[cachedirlen-1] = '/';
handle->cachedirs = alpm_list_add(handle->cachedirs, newcachedir);
_alpm_log(PM_LOG_DEBUG, "option 'cachedir' = %s\n", newcachedir);
- return(0);
+ return 0;
}
-void SYMEXPORT alpm_option_set_cachedirs(alpm_list_t *cachedirs)
+int SYMEXPORT alpm_option_set_cachedirs(alpm_list_t *cachedirs)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
if(handle->cachedirs) FREELIST(handle->cachedirs);
- if(cachedirs) handle->cachedirs = cachedirs;
+ handle->cachedirs = cachedirs;
+ return 0;
}
int SYMEXPORT alpm_option_remove_cachedir(const char *cachedir)
@@ -427,9 +436,9 @@ int SYMEXPORT alpm_option_remove_cachedir(const char *cachedir)
FREE(newcachedir);
if(vdata != NULL) {
FREE(vdata);
- return(1);
+ return 1;
}
- return(0);
+ return 0;
}
int SYMEXPORT alpm_option_set_logfile(const char *logfile)
@@ -441,7 +450,7 @@ int SYMEXPORT alpm_option_set_logfile(const char *logfile)
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
if(!logfile) {
pm_errno = PM_ERR_WRONG_ARGS;
- return(-1);
+ return -1;
}
handle->logfile = strdup(logfile);
@@ -456,26 +465,47 @@ int SYMEXPORT alpm_option_set_logfile(const char *logfile)
handle->logstream = NULL;
}
_alpm_log(PM_LOG_DEBUG, "option 'logfile' = %s\n", handle->logfile);
- return(0);
+ return 0;
+}
+
+int SYMEXPORT alpm_option_set_signaturedir(const char *signaturedir)
+{
+ ALPM_LOG_FUNC;
+
+ if(!signaturedir) {
+ pm_errno = PM_ERR_WRONG_ARGS;
+ return -1;
+ }
+
+ if(handle->signaturedir) {
+ FREE(handle->signaturedir);
+ }
+ handle->signaturedir = strdup(signaturedir);
+
+ _alpm_log(PM_LOG_DEBUG, "option 'signaturedir' = %s\n", handle->signaturedir);
+ return 0;
}
-void SYMEXPORT alpm_option_set_usesyslog(int usesyslog)
+int SYMEXPORT alpm_option_set_usesyslog(int usesyslog)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
handle->usesyslog = usesyslog;
+ return 0;
}
-void SYMEXPORT alpm_option_add_noupgrade(const char *pkg)
+int SYMEXPORT alpm_option_add_noupgrade(const char *pkg)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -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_list_t *noupgrade)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
if(handle->noupgrade) FREELIST(handle->noupgrade);
- if(noupgrade) handle->noupgrade = noupgrade;
+ handle->noupgrade = noupgrade;
+ return 0;
}
int SYMEXPORT alpm_option_remove_noupgrade(const char *pkg)
@@ -485,22 +515,24 @@ int SYMEXPORT alpm_option_remove_noupgrade(const char *pkg)
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(const char *pkg)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -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_list_t *noextract)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
if(handle->noextract) FREELIST(handle->noextract);
- if(noextract) handle->noextract = noextract;
+ handle->noextract = noextract;
+ return 0;
}
int SYMEXPORT alpm_option_remove_noextract(const char *pkg)
@@ -510,22 +542,24 @@ int SYMEXPORT alpm_option_remove_noextract(const char *pkg)
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(const char *pkg)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -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_list_t *ignorepkgs)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
if(handle->ignorepkg) FREELIST(handle->ignorepkg);
- if(ignorepkgs) handle->ignorepkg = ignorepkgs;
+ handle->ignorepkg = ignorepkgs;
+ return 0;
}
int SYMEXPORT alpm_option_remove_ignorepkg(const char *pkg)
@@ -535,22 +569,24 @@ int SYMEXPORT alpm_option_remove_ignorepkg(const char *pkg)
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_ignoregrp(const char *grp)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
handle->ignoregrp = alpm_list_add(handle->ignoregrp, strdup(grp));
+ return 0;
}
-void SYMEXPORT alpm_option_set_ignoregrps(alpm_list_t *ignoregrps)
+int SYMEXPORT alpm_option_set_ignoregrps(alpm_list_t *ignoregrps)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
if(handle->ignoregrp) FREELIST(handle->ignoregrp);
- if(ignoregrps) handle->ignoregrp = ignoregrps;
+ handle->ignoregrp = ignoregrps;
+ return 0;
}
int SYMEXPORT alpm_option_remove_ignoregrp(const char *grp)
@@ -560,28 +596,49 @@ int SYMEXPORT alpm_option_remove_ignoregrp(const char *grp)
handle->ignoregrp = alpm_list_remove_str(handle->ignoregrp, 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(const char *arch)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -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(int usedelta)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
handle->usedelta = usedelta;
+ return 0;
}
-void SYMEXPORT alpm_option_set_checkspace(int checkspace)
+int SYMEXPORT alpm_option_set_checkspace(int checkspace)
{
- ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
handle->checkspace = checkspace;
+ return 0;
+}
+
+int SYMEXPORT alpm_option_set_default_sigverify(pgp_verify_t level)
+{
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ ASSERT(level != PM_PGP_VERIFY_UNKNOWN, RET_ERR(PM_ERR_WRONG_ARGS, -1));
+ handle->sigverify = level;
+ return 0;
+}
+
+pgp_verify_t SYMEXPORT alpm_option_get_default_sigverify()
+{
+ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, PM_PGP_VERIFY_UNKNOWN));
+ return handle->sigverify;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/handle.h b/lib/libalpm/handle.h
index 2d962fe6..aa00b6f0 100644
--- a/lib/libalpm/handle.h
+++ b/lib/libalpm/handle.h
@@ -29,6 +29,10 @@
#include "alpm.h"
#include "trans.h"
+#ifdef HAVE_LIBCURL
+#include <curl/curl.h>
+#endif
+
typedef struct _pmhandle_t {
/* internal usage */
pmdb_t *db_local; /* local db pointer */
@@ -37,6 +41,12 @@ typedef struct _pmhandle_t {
FILE *lckstream; /* lock file stream pointer if one exists */
pmtrans_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 */
alpm_cb_download dlcb; /* Download callback function */
@@ -48,6 +58,7 @@ 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 *signaturedir; /* Directory where GnuPG files are stored */
alpm_list_t *cachedirs; /* Paths to pacman cache directories */
/* package lists */
@@ -57,10 +68,11 @@ typedef struct _pmhandle_t {
alpm_list_t *ignoregrp; /* 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 */
+ 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 */
+ pgp_verify_t sigverify; /* Default signature verification level */
} pmhandle_t;
/* global handle variable */
diff --git a/lib/libalpm/log.c b/lib/libalpm/log.c
index 09c6fb84..9093af7b 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"
@@ -64,7 +61,7 @@ int SYMEXPORT alpm_logaction(const char *fmt, ...)
} else {
pm_errno = PM_ERR_SYSTEM;
}
- return(-1);
+ return -1;
}
}
@@ -83,7 +80,7 @@ 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;
}
/** @} */
diff --git a/lib/libalpm/package.c b/lib/libalpm/package.c
index f2f15af4..990f532d 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"
@@ -58,7 +54,7 @@ int SYMEXPORT alpm_pkg_free(pmpkg_t *pkg)
_alpm_pkg_free(pkg);
}
- return(0);
+ return 0;
}
/** Check the integrity (with md5) of a package from the sync cache. */
@@ -78,13 +74,13 @@ int SYMEXPORT alpm_pkg_checkmd5sum(pmpkg_t *pkg)
retval = _alpm_test_md5sum(fpath, alpm_pkg_get_md5sum(pkg));
if(retval == 0) {
- return(0);
- } else if (retval == 1) {
+ return 0;
+ } else if(retval == 1) {
pm_errno = PM_ERR_PKG_INVALID;
retval = -1;
}
- return(retval);
+ return retval;
}
/* Default package accessor functions. These will get overridden by any
@@ -92,8 +88,6 @@ int SYMEXPORT alpm_pkg_checkmd5sum(pmpkg_t *pkg)
* 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; }
@@ -117,17 +111,28 @@ 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 void *_pkg_changelog_open(pmpkg_t UNUSED *pkg)
+{
+ return NULL;
+}
+
+static size_t _pkg_changelog_read(void UNUSED *ptr, size_t UNUSED size,
+ const pmpkg_t UNUSED *pkg, const UNUSED void *fp)
+{
+ return 0;
+}
+
+static int _pkg_changelog_close(const pmpkg_t UNUSED *pkg,
+ void UNUSED *fp)
+{
+ return EOF;
+}
/** 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,
@@ -166,12 +171,12 @@ const char SYMEXPORT *alpm_pkg_get_filename(pmpkg_t *pkg)
const char SYMEXPORT *alpm_pkg_get_name(pmpkg_t *pkg)
{
- return pkg->ops->get_name(pkg);
+ return pkg->name;
}
const char SYMEXPORT *alpm_pkg_get_version(pmpkg_t *pkg)
{
- return pkg->ops->get_version(pkg);
+ return pkg->version;
}
const char SYMEXPORT *alpm_pkg_get_desc(pmpkg_t *pkg)
@@ -277,10 +282,10 @@ alpm_list_t SYMEXPORT *alpm_pkg_get_backup(pmpkg_t *pkg)
pmdb_t SYMEXPORT *alpm_pkg_get_db(pmpkg_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);
- return(pkg->origin_data.db);
+ return pkg->origin_data.db;
}
/** Open a package changelog for reading. */
@@ -356,7 +361,7 @@ alpm_list_t SYMEXPORT *alpm_pkg_compute_requiredby(pmpkg_t *pkg)
reqs = alpm_list_msort(reqs, alpm_list_count(reqs), _alpm_str_cmp);
}
}
- return(reqs);
+ return reqs;
}
/** @} */
@@ -369,7 +374,7 @@ pmpkg_t *_alpm_pkg_new(void)
CALLOC(pkg, 1, sizeof(pmpkg_t), RET_ERR(PM_ERR_MEMORY, NULL));
- return(pkg);
+ return pkg;
}
pmpkg_t *_alpm_pkg_dup(pmpkg_t *pkg)
@@ -420,7 +425,7 @@ pmpkg_t *_alpm_pkg_dup(pmpkg_t *pkg)
}
newpkg->infolevel = pkg->infolevel;
- return(newpkg);
+ return newpkg;
}
void _alpm_pkg_free(pmpkg_t *pkg)
@@ -438,6 +443,7 @@ 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);
@@ -497,7 +503,7 @@ 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));
+ return strcoll(pkg1->name, pkg2->name);
}
/* Test for existence of a package in a alpm_list_t*
@@ -511,7 +517,7 @@ pmpkg_t *_alpm_pkg_find(alpm_list_t *haystack, const char *needle)
ALPM_LOG_FUNC;
if(needle == NULL || haystack == NULL) {
- return(NULL);
+ return NULL;
}
needle_hash = _alpm_hash_sdbm(needle);
@@ -527,11 +533,11 @@ 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.
@@ -549,18 +555,18 @@ int _alpm_pkg_should_ignore(pmpkg_t *pkg)
/* 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)) {
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..debb239c 100644
--- a/lib/libalpm/package.h
+++ b/lib/libalpm/package.h
@@ -24,11 +24,14 @@
#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 "db.h"
+#include "signing.h"
typedef enum _pmpkgfrom_t {
PKG_FROM_FILE = 1,
@@ -45,8 +48,6 @@ typedef enum _pmpkgfrom_t {
*/
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 *);
@@ -96,6 +97,7 @@ struct __pmpkg_t {
char *url;
char *packager;
char *md5sum;
+ char *base64_sig;
char *arch;
time_t builddate;
@@ -137,6 +139,10 @@ 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);
+
+pmpkg_t *_alpm_pkg_load_internal(const char *filename, int full,
+ const char *md5sum, const char *base64_sig, pgp_verify_t check_sig);
+
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);
diff --git a/lib/libalpm/pkghash.c b/lib/libalpm/pkghash.c
index 6dc43243..f4153300 100644
--- a/lib/libalpm/pkghash.c
+++ b/lib/libalpm/pkghash.c
@@ -72,13 +72,13 @@ pmpkghash_t *_alpm_pkghash_create(size_t size)
if(hash->buckets < size) {
_alpm_log(PM_LOG_ERROR, _("database larger than maximum size\n"));
free(hash);
- return(NULL);
+ return NULL;
}
- CALLOC(hash->hash_table, hash->buckets, sizeof(alpm_list_t*), \
+ CALLOC(hash->hash_table, hash->buckets, sizeof(alpm_list_t *), \
free(hash); RET_ERR(PM_ERR_MEMORY, NULL));
- return(hash);
+ return hash;
}
static size_t get_hash_position(unsigned long name_hash, pmpkghash_t *hash)
@@ -92,7 +92,7 @@ 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 */
@@ -123,7 +123,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;
@@ -144,7 +144,7 @@ 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)
@@ -153,7 +153,7 @@ static pmpkghash_t *pkghash_add_pkg(pmpkghash_t *hash, pmpkg_t *pkg, int sorted)
size_t position;
if(pkg == NULL || hash == NULL) {
- return(hash);
+ return hash;
}
if((hash->entries + 1) / MAX_HASH_LOAD > hash->buckets) {
@@ -164,7 +164,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,17 +179,17 @@ 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)
{
- 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)
{
- 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)
@@ -217,7 +217,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;
}
/**
@@ -240,7 +240,7 @@ 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;
@@ -277,13 +277,13 @@ 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)
@@ -307,7 +307,7 @@ pmpkg_t *_alpm_pkghash_find(pmpkghash_t *hash, const char *name)
ALPM_LOG_FUNC;
if(name == NULL || hash == NULL) {
- return(NULL);
+ return NULL;
}
name_hash = _alpm_hash_sdbm(name);
@@ -318,13 +318,13 @@ pmpkg_t *_alpm_pkghash_find(pmpkghash_t *hash, const char *name)
pmpkg_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/remove.c b/lib/libalpm/remove.c
index 22ae2bb8..2d840ceb 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,7 +43,6 @@
#include "db.h"
#include "deps.h"
#include "handle.h"
-#include "alpm.h"
int SYMEXPORT alpm_remove_pkg(pmpkg_t *pkg)
{
@@ -61,15 +59,16 @@ int SYMEXPORT alpm_remove_pkg(pmpkg_t *pkg)
ASSERT(trans->state == STATE_INITIALIZED,
RET_ERR(PM_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);
}
- _alpm_log(PM_LOG_DEBUG, "adding %s in the target list\n", pkgname);
+ _alpm_log(PM_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,
@@ -160,7 +159,7 @@ int _alpm_remove_prepare(pmtrans_t *trans, pmdb_t *db, alpm_list_t **data)
if(trans->flags & PM_TRANS_FLAG_CASCADE) {
remove_prepare_cascade(trans, db, lp);
- } else if (trans->flags & PM_TRANS_FLAG_UNNEEDED) {
+ } else if(trans->flags & PM_TRANS_FLAG_UNNEEDED) {
/* Remove needed packages (which would break dependencies)
* from target list */
remove_prepare_keep_needed(trans, db, lp);
@@ -193,7 +192,7 @@ int _alpm_remove_prepare(pmtrans_t *trans, pmdb_t *db, alpm_list_t **data)
EVENT(trans, PM_TRANS_EVT_CHECKDEPS_DONE, NULL, NULL);
}
- return(0);
+ return 0;
}
static int can_remove_file(const char *path, alpm_list_t *skip)
@@ -204,7 +203,7 @@ static int can_remove_file(const char *path, alpm_list_t *skip)
if(alpm_list_find_str(skip, file)) {
/* 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 */
@@ -214,11 +213,11 @@ static int can_remove_file(const char *path, alpm_list_t *skip)
* it - ignore "chmod -w" simple permission failures */
_alpm_log(PM_LOG_ERROR, _("cannot remove file '%s': %s\n"),
file, strerror(errno));
- return(0);
+ return 0;
}
}
- return(1);
+ return 1;
}
/* Helper function for iterating through a package's file and deleting them
@@ -359,7 +358,7 @@ db:
pkgname);
}
- return(0);
+ return 0;
}
int _alpm_remove_packages(pmtrans_t *trans, pmdb_t *db)
@@ -378,12 +377,12 @@ int _alpm_remove_packages(pmtrans_t *trans, pmdb_t *db)
for(targ = trans->remove; targ; targ = targ->next) {
int position = 0;
char scriptlet[PATH_MAX];
- info = (pmpkg_t*)targ->data;
+ info = (pmpkg_t *)targ->data;
const char *pkgname = NULL;
size_t targcount = alpm_list_count(targ);
if(handle->trans->state == STATE_INTERRUPTED) {
- return(0);
+ return 0;
}
/* get the name now so we can use it after package is removed */
@@ -465,7 +464,7 @@ int _alpm_remove_packages(pmtrans_t *trans, pmdb_t *db)
/* run ldconfig if it exists */
_alpm_ldconfig(handle->root);
- return(0);
+ return 0;
}
/* vim: set ts=2 sw=2 noet: */
diff --git a/lib/libalpm/signing.c b/lib/libalpm/signing.c
new file mode 100644
index 00000000..9bb9d0ad
--- /dev/null
+++ b/lib/libalpm/signing.c
@@ -0,0 +1,410 @@
+/*
+ * 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"
+
+#if HAVE_LIBGPGME
+#define CHECK_ERR(void) do { \
+ if(err != GPG_ERR_NO_ERROR) { goto error; } \
+ } while(0)
+
+static const char *gpgme_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 alpm_list_t *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);
+ }
+ return summary;
+}
+
+static alpm_list_t *gpgme_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. */
+ summary = sigsum_test_bit(sigsum, summary, GPGME_SIGSUM_VALID, "valid");
+ /* The signature is good. */
+ summary = sigsum_test_bit(sigsum, summary, GPGME_SIGSUM_GREEN, "green");
+ /* The signature is bad. */
+ summary = sigsum_test_bit(sigsum, summary, GPGME_SIGSUM_RED, "red");
+ /* One key has been revoked. */
+ summary = sigsum_test_bit(sigsum, summary, GPGME_SIGSUM_KEY_REVOKED, "key revoked");
+ /* One key has expired. */
+ summary = sigsum_test_bit(sigsum, summary, GPGME_SIGSUM_KEY_EXPIRED, "key expired");
+ /* The signature has expired. */
+ summary = sigsum_test_bit(sigsum, summary, GPGME_SIGSUM_SIG_EXPIRED, "sig expired");
+ /* Can't verify: key missing. */
+ summary = sigsum_test_bit(sigsum, summary, GPGME_SIGSUM_KEY_MISSING, "key missing");
+ /* CRL not available. */
+ summary = sigsum_test_bit(sigsum, summary, GPGME_SIGSUM_CRL_MISSING, "crl missing");
+ /* Available CRL is too old. */
+ summary = sigsum_test_bit(sigsum, summary, GPGME_SIGSUM_CRL_TOO_OLD, "crl too old");
+ /* A policy was not met. */
+ summary = sigsum_test_bit(sigsum, summary, GPGME_SIGSUM_BAD_POLICY, "bad policy");
+ /* A system error occured. */
+ summary = 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 gpgme_init(void)
+{
+ static int init = 0;
+ const char *version;
+ gpgme_error_t err;
+ gpgme_engine_info_t enginfo;
+
+ ALPM_LOG_FUNC;
+
+ if(init) {
+ /* we already successfully initialized the library */
+ return 0;
+ }
+
+ if(!alpm_option_get_signaturedir()) {
+ RET_ERR(PM_ERR_SIG_MISSINGDIR, 1);
+ }
+
+ /* calling gpgme_check_version() returns the current version and runs
+ * some internal library setup code */
+ version = gpgme_check_version(NULL);
+ _alpm_log(PM_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,
+ alpm_option_get_signaturedir());
+ CHECK_ERR();
+ err = gpgme_get_engine_info(&enginfo);
+ CHECK_ERR();
+ _alpm_log(PM_LOG_DEBUG, "GPGME engine info: file=%s, home=%s\n",
+ enginfo->file_name, enginfo->home_dir);
+
+ init = 1;
+ return 0;
+
+error:
+ _alpm_log(PM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(err));
+ RET_ERR(PM_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.
+ * @param path the full path to a file
+ * @param base64_sig PGP signature data in base64 encoding; if NULL, expect a
+ * signature file next to 'path'
+ * @return a int value : 0 (valid), 1 (invalid), -1 (an error occured)
+ */
+int _alpm_gpgme_checksig(const char *path, const char *base64_sig)
+{
+ int ret = 0;
+ gpgme_error_t err;
+ gpgme_ctx_t ctx;
+ gpgme_data_t filedata, sigdata;
+ gpgme_verify_result_t result;
+ gpgme_signature_t gpgsig;
+ char *sigpath = NULL;
+ unsigned char *decoded_sigdata = NULL;
+ FILE *file = NULL, *sigfile = NULL;
+
+ ALPM_LOG_FUNC;
+
+ if(!path || access(path, R_OK) != 0) {
+ RET_ERR(PM_ERR_NOT_A_FILE, -1);
+ }
+
+ if(!base64_sig) {
+ size_t len = strlen(path) + 5;
+ CALLOC(sigpath, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, -1));
+ snprintf(sigpath, len, "%s.sig", path);
+
+ if(!access(sigpath, R_OK) == 0) {
+ FREE(sigpath);
+ RET_ERR(PM_ERR_SIG_UNKNOWN, -1);
+ }
+ }
+
+ if(gpgme_init()) {
+ /* pm_errno was set in gpgme_init() */
+ return -1;
+ }
+
+ _alpm_log(PM_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) {
+ pm_errno = PM_ERR_NOT_A_FILE;
+ ret = -1;
+ 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) {
+ ret = -1;
+ 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) {
+ pm_errno = PM_ERR_NOT_A_FILE;
+ ret = -1;
+ 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();
+ result = gpgme_op_verify_result(ctx);
+ gpgsig = result->signatures;
+ if(!gpgsig || gpgsig->next) {
+ int count = 0;
+ while(gpgsig) {
+ count++;
+ gpgsig = gpgsig->next;
+ }
+ _alpm_log(PM_LOG_ERROR, _("Unexpected number of signatures (%d)\n"),
+ count);
+ ret = -1;
+ goto error;
+ }
+
+ {
+ alpm_list_t *summary_list, *summary;
+
+ _alpm_log(PM_LOG_DEBUG, "fingerprint: %s\n", gpgsig->fpr);
+ summary_list = gpgme_list_sigsum(gpgsig->summary);
+ for(summary = summary_list; summary; summary = summary->next) {
+ _alpm_log(PM_LOG_DEBUG, "summary: %s\n", (const char *)summary->data);
+ }
+ alpm_list_free(summary_list);
+ _alpm_log(PM_LOG_DEBUG, "status: %s\n", gpgme_strerror(gpgsig->status));
+ _alpm_log(PM_LOG_DEBUG, "timestamp: %lu\n", gpgsig->timestamp);
+ _alpm_log(PM_LOG_DEBUG, "exp_timestamp: %lu\n", gpgsig->exp_timestamp);
+ _alpm_log(PM_LOG_DEBUG, "validity: %s\n",
+ gpgme_string_validity(gpgsig->validity));
+ _alpm_log(PM_LOG_DEBUG, "validity_reason: %s\n",
+ gpgme_strerror(gpgsig->validity_reason));
+ _alpm_log(PM_LOG_DEBUG, "pubkey algo: %s\n",
+ gpgme_pubkey_algo_name(gpgsig->pubkey_algo));
+ _alpm_log(PM_LOG_DEBUG, "hash algo: %s\n",
+ gpgme_hash_algo_name(gpgsig->hash_algo));
+ }
+
+ if(gpgsig->summary & GPGME_SIGSUM_VALID) {
+ /* good signature, continue */
+ _alpm_log(PM_LOG_DEBUG, _("File %s has a valid signature.\n"),
+ path);
+ } else if(gpgsig->summary & GPGME_SIGSUM_GREEN) {
+ /* 'green' signature, not sure what to do here */
+ _alpm_log(PM_LOG_WARNING, _("File %s has a green signature.\n"),
+ path);
+ } else if(gpgsig->summary & GPGME_SIGSUM_KEY_MISSING) {
+ pm_errno = PM_ERR_SIG_UNKNOWN;
+ _alpm_log(PM_LOG_WARNING, _("File %s has a signature from an unknown key.\n"),
+ path);
+ ret = -1;
+ } else {
+ /* we'll capture everything else here */
+ pm_errno = PM_ERR_SIG_INVALID;
+ _alpm_log(PM_LOG_ERROR, _("File %s has an invalid signature.\n"),
+ path);
+ ret = 1;
+ }
+
+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(err != GPG_ERR_NO_ERROR) {
+ _alpm_log(PM_LOG_ERROR, _("GPGME error: %s\n"), gpgme_strerror(err));
+ RET_ERR(PM_ERR_GPGME, -1);
+ }
+ return ret;
+}
+#else
+int _alpm_gpgme_checksig(const char *path, const char *base64_sig)
+{
+ return -1;
+}
+#endif
+
+/**
+ * Determines the necessity of checking for a valid PGP signature
+ * @param db the sync database to query
+ *
+ * @return signature verification level
+ */
+pgp_verify_t _alpm_db_get_sigverify_level(pmdb_t *db)
+{
+ ALPM_LOG_FUNC;
+ ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, PM_PGP_VERIFY_UNKNOWN));
+
+ if(db->pgp_verify != PM_PGP_VERIFY_UNKNOWN) {
+ return db->pgp_verify;
+ } else {
+ return alpm_option_get_default_sigverify();
+ }
+}
+
+/**
+ * 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(pmpkg_t *pkg)
+{
+ ALPM_LOG_FUNC;
+ ASSERT(pkg != NULL, return 0);
+
+ return _alpm_gpgme_checksig(alpm_pkg_get_filename(pkg), pkg->base64_sig);
+}
+
+/**
+ * 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(pmdb_t *db)
+{
+ ALPM_LOG_FUNC;
+ ASSERT(db != NULL, return 0);
+
+ return _alpm_gpgme_checksig(_alpm_db_path(db), NULL);
+}
+
+/* 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..8d8c1643
--- /dev/null
+++ b/lib/libalpm/signing.h
@@ -0,0 +1,29 @@
+/*
+ * 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(const char *path, const char *base64_sig);
+pgp_verify_t _alpm_db_get_sigverify_level(pmdb_t *db);
+
+#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..8dd51aaa 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,13 +48,14 @@
#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)
{
- ASSERT(pkg != NULL, return(NULL));
+ ASSERT(pkg != NULL, return NULL);
alpm_list_t *i;
pmpkg_t *spkg = NULL;
@@ -68,7 +67,7 @@ pmpkg_t SYMEXPORT *alpm_sync_newversion(pmpkg_t *pkg, alpm_list_t *dbs_sync)
if(spkg == NULL) {
_alpm_log(PM_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 */
@@ -76,15 +75,13 @@ pmpkg_t SYMEXPORT *alpm_sync_newversion(pmpkg_t *pkg, alpm_list_t *dbs_sync)
_alpm_log(PM_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)
- */
+/** Search for packages to upgrade and add them to the transaction. */
int SYMEXPORT alpm_sync_sysupgrade(int enable_downgrade)
{
alpm_list_t *i, *j, *k;
@@ -116,7 +113,8 @@ int SYMEXPORT alpm_sync_sysupgrade(int enable_downgrade)
pmdb_t *sdb = j->data;
/* Check sdb */
pmpkg_t *spkg = _alpm_db_get_pkgfromcache(sdb, lpkg->name);
- if(spkg) { /* 1. literal was found in sdb */
+ 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",
@@ -146,8 +144,10 @@ int SYMEXPORT alpm_sync_sysupgrade(int enable_downgrade)
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;
@@ -183,7 +183,8 @@ int SYMEXPORT alpm_sync_sysupgrade(int enable_downgrade)
if(alpm_pkg_get_reason(lpkg) == PM_PKG_REASON_EXPLICIT) {
tpkg->reason = PM_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);
@@ -200,7 +201,7 @@ int SYMEXPORT alpm_sync_sysupgrade(int enable_downgrade)
}
}
- return(0);
+ return 0;
}
/** Find group members across a list of databases.
@@ -242,7 +243,7 @@ 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
@@ -258,7 +259,7 @@ static int compute_download_size(pmpkg_t *newpkg)
if(newpkg->origin != PKG_FROM_SYNCDB) {
newpkg->infolevel |= INFRQ_DSIZE;
newpkg->download_size = 0;
- return(0);
+ return 0;
}
fname = alpm_pkg_get_filename(newpkg);
@@ -295,7 +296,7 @@ static int compute_download_size(pmpkg_t *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)
@@ -355,7 +356,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
int remove_unresolvable = 0;
QUESTION(handle->trans, PM_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
@@ -551,7 +552,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
@@ -564,13 +565,13 @@ off_t SYMEXPORT alpm_pkg_download_size(pmpkg_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.
@@ -650,13 +651,14 @@ 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);
+ pm_errno = PM_ERR_DLT_PATCHFAILED;
ret = 1;
break;
}
}
}
- return(ret);
+ return ret;
}
/** Compares the md5sum of a file to the expected value.
@@ -665,47 +667,71 @@ 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(pmtrans_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, PM_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(pmtrans_t *trans, 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_LOG_FUNC;
+ if(!deltas) {
+ return 0;
+ }
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
+ /* 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);
+ char *filepath = _alpm_filecache_find(filename);
+ const char *md5sum = alpm_delta_get_md5sum(d);
+
+ if(test_md5sum(trans, filepath, md5sum) != 0) {
+ errors++;
+ *data = alpm_list_add(*data, strdup(filename));
+ }
+ FREE(filepath);
+ }
+ if(errors) {
+ pm_errno = PM_ERR_DLT_INVALID;
+ return -1;
+ }
+ EVENT(trans, PM_TRANS_EVT_DELTA_INTEGRITY_DONE, NULL, NULL);
+
+ /* 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);
+ return ret;
+}
+
+static int download_files(pmtrans_t *trans, alpm_list_t **deltas)
+{
+ const char *cachedir;
+ alpm_list_t *i, *j;
+ alpm_list_t *files = NULL;
+ int errors = 0;
cachedir = _alpm_filecache_setup();
trans->state = STATE_DOWNLOADING;
@@ -738,26 +764,18 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
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;
-
- if(d->download_size != 0) {
- /* add the delta filename to the download list if needed */
- files = alpm_list_add(files, strdup(d->delta));
+ pmdelta_t *delta = dlts->data;
+ if(delta->download_size != 0) {
+ files = alpm_list_add(files, strdup(delta->delta));
}
-
/* 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) {
+ files = alpm_list_add(files, strdup(fname));
}
}
@@ -765,17 +783,40 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
if(files) {
EVENT(trans, PM_TRANS_EVT_RETRIEVE_START, current->treename, NULL);
- errors = _alpm_download_files(files, current->servers, cachedir);
+ for(j = files; j; j = j->next) {
+ const char *filename = j->data;
+ alpm_list_t *server;
+ int ret = -1;
+ for(server = current->servers; server; server = server->next) {
+ const char *server_url = server->data;
+ char *fileurl;
+ size_t len;
+
+ /* print server + filename into a buffer */
+ len = strlen(server_url) + strlen(filename) + 2;
+ CALLOC(fileurl, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, -1));
+ snprintf(fileurl, len, "%s/%s", server_url, filename);
+
+ ret = _alpm_download(fileurl, cachedir, 0, 1, 0);
+ FREE(fileurl);
+ if(ret != -1) {
+ break;
+ }
+ }
+ if(ret == -1) {
+ errors++;
+ }
+ }
- if (errors) {
+ FREELIST(files);
+ if(errors) {
_alpm_log(PM_LOG_WARNING, _("failed to retrieve some files from %s\n"),
current->treename);
if(pm_errno == 0) {
pm_errno = PM_ERR_RETRIEVE;
}
- goto error;
+ return -1;
}
- FREELIST(files);
}
}
@@ -789,70 +830,61 @@ 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);
+int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
+{
+ alpm_list_t *i;
+ alpm_list_t *deltas = NULL;
+ size_t numtargs, current = 0, replaces = 0;
+ int errors;
- 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);
+ ALPM_LOG_FUNC;
- 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);
+ ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
- /* 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(trans, &deltas)) {
+ alpm_list_free(deltas);
+ return -1;
+ }
- if(ret) {
- pm_errno = PM_ERR_DLT_PATCHFAILED;
- goto error;
- }
+ if(validate_deltas(trans, 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);
errors = 0;
+
for(i = trans->add; i; i = i->next, current++) {
pmpkg_t *spkg = i->data;
int percent = (current * 100) / numtargs;
+ const char *filename;
+ char *filepath;
+ pgp_verify_t check_sig;
+
+ PROGRESS(trans, PM_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(filename);
+ pmdb_t *sdb = alpm_pkg_get_db(spkg);
+ check_sig = _alpm_db_get_sigverify_level(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);
+ pmpkg_t *pkgfile =_alpm_pkg_load_internal(filepath, 1, spkg->md5sum,
+ spkg->base64_sig, check_sig);
+ if(!pkgfile) {
errors++;
*data = alpm_list_add(*data, strdup(filename));
FREE(filepath);
@@ -863,17 +895,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,
numtargs, current);
EVENT(trans, PM_TRANS_EVT_INTEGRITY_DONE, NULL, NULL);
+
+
if(errors) {
- pm_errno = PM_ERR_PKG_INVALID;
- goto error;
+ RET_ERR(PM_ERR_PKG_INVALID, -1);
}
if(trans->flags & PM_TRANS_FLAG_DOWNLOADONLY) {
- ret = 0;
- goto error;
+ return 0;
}
trans->state = STATE_COMMITING;
@@ -888,14 +921,13 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
alpm_list_t *conflict = _alpm_db_find_fileconflicts(db_local, trans,
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(PM_ERR_FILE_CONFLICTS, -1);
}
EVENT(trans, PM_TRANS_EVT_FILECONFLICTS_DONE, NULL, NULL);
@@ -908,7 +940,7 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
_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;
+ return -1;
}
EVENT(trans, PM_TRANS_EVT_DISKSPACE_DONE, NULL, NULL);
@@ -920,7 +952,7 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
/* 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;
+ return -1;
}
}
@@ -928,14 +960,10 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
_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;
+ 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/trans.c b/lib/libalpm/trans.c
index bf9ef722..5ffb5df2 100644
--- a/lib/libalpm/trans.c
+++ b/lib/libalpm/trans.c
@@ -28,8 +28,6 @@
#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>
@@ -41,11 +39,9 @@
#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
@@ -68,22 +64,22 @@ static int make_lock(pmhandle_t *handle)
}
if(_alpm_makepath(dir)) {
FREE(dir);
- return(-1);
+ return -1;
}
FREE(dir);
do {
fd = open(handle->lockfile, O_WRONLY | O_CREAT | O_EXCL, 0000);
- } while (fd == -1 && errno == EINTR);
+ } 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 0;
}
- return(-1);
+ return -1;
}
/* Remove a lock file */
@@ -94,9 +90,9 @@ static int remove_lock(pmhandle_t *handle)
handle->lckstream = NULL;
}
if(unlink(handle->lockfile) == -1 && errno != ENOENT) {
- return(-1);
+ return -1;
}
- return(0);
+ return 0;
}
/** Initialize the transaction. */
@@ -144,7 +140,7 @@ int SYMEXPORT alpm_trans_init(pmtransflag_t flags,
RET_ERR(PM_ERR_DB_VERSION, -1);
}
- return(0);
+ return 0;
}
static alpm_list_t *check_arch(alpm_list_t *pkgs)
@@ -154,7 +150,7 @@ static alpm_list_t *check_arch(alpm_list_t *pkgs)
const char *arch = alpm_option_get_arch();
if(!arch) {
- return(NULL);
+ return NULL;
}
for(i = pkgs; i; i = i->next) {
pmpkg_t *pkg = i->data;
@@ -169,7 +165,7 @@ static alpm_list_t *check_arch(alpm_list_t *pkgs)
invalid = alpm_list_add(invalid, string);
}
}
- return(invalid);
+ return invalid;
}
/** Prepare a transaction. */
@@ -190,7 +186,7 @@ int SYMEXPORT alpm_trans_prepare(alpm_list_t **data)
/* 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);
@@ -204,18 +200,18 @@ int SYMEXPORT alpm_trans_prepare(alpm_list_t **data)
if(trans->add == NULL) {
if(_alpm_remove_prepare(trans, handle->db_local, 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) {
/* pm_errno is set by _alpm_sync_prepare() */
- return(-1);
+ return -1;
}
}
trans->state = STATE_PREPARED;
- return(0);
+ return 0;
}
/** Commit a transaction. */
@@ -237,7 +233,7 @@ int SYMEXPORT alpm_trans_commit(alpm_list_t **data)
/* If there's nothing to do, return without complaining */
if(trans->add == NULL && trans->remove == NULL) {
- return(0);
+ return 0;
}
trans->state = STATE_COMMITING;
@@ -245,18 +241,18 @@ int SYMEXPORT alpm_trans_commit(alpm_list_t **data)
if(trans->add == NULL) {
if(_alpm_remove_packages(trans, handle->db_local) == -1) {
/* pm_errno is set by _alpm_remove_commit() */
- return(-1);
+ return -1;
}
} else {
if(_alpm_sync_commit(trans, handle->db_local, 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. */
@@ -276,7 +272,7 @@ int SYMEXPORT alpm_trans_interrupt(void)
trans->state = STATE_INTERRUPTED;
- return(0);
+ return 0;
}
/** Release a transaction. */
@@ -308,7 +304,7 @@ int SYMEXPORT alpm_trans_release(void)
}
}
- return(0);
+ return 0;
}
/** @} */
@@ -322,7 +318,7 @@ pmtrans_t *_alpm_trans_new(void)
CALLOC(trans, 1, sizeof(pmtrans_t), RET_ERR(PM_ERR_MEMORY, NULL));
trans->state = STATE_IDLE;
- return(trans);
+ return trans;
}
void _alpm_trans_free(pmtrans_t *trans)
@@ -351,7 +347,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 +358,16 @@ 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)
+ const char *script, const char *ver,
+ const char *oldver, pmtrans_t UNUSED *trans)
{
char scriptfn[PATH_MAX];
char cmdline[PATH_MAX];
@@ -386,7 +382,7 @@ int _alpm_runscriptlet(const char *root, const char *installfn,
if(access(installfn, R_OK)) {
/* not found */
_alpm_log(PM_LOG_DEBUG, "scriptlet '%s' not found\n", installfn);
- return(0);
+ return 0;
}
/* creates a directory in $root/tmp/ for copying/extracting the scriptlet */
@@ -397,7 +393,7 @@ int _alpm_runscriptlet(const char *root, const char *installfn,
snprintf(tmpdir, PATH_MAX, "%stmp/alpm_XXXXXX", root);
if(mkdtemp(tmpdir) == NULL) {
_alpm_log(PM_LOG_ERROR, _("could not create temp directory\n"));
- return(1);
+ return 1;
} else {
clean_tmpdir = 1;
}
@@ -443,7 +439,7 @@ cleanup:
_alpm_log(PM_LOG_WARNING, _("could not remove tmpdir %s\n"), tmpdir);
}
- return(retval);
+ return retval;
}
int SYMEXPORT alpm_trans_get_flags()
@@ -458,8 +454,8 @@ int SYMEXPORT alpm_trans_get_flags()
alpm_list_t SYMEXPORT * alpm_trans_get_add()
{
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(handle->trans != NULL, return(NULL));
+ ASSERT(handle != NULL, return NULL);
+ ASSERT(handle->trans != NULL, return NULL);
return handle->trans->add;
}
@@ -467,8 +463,8 @@ alpm_list_t SYMEXPORT * alpm_trans_get_add()
alpm_list_t SYMEXPORT * alpm_trans_get_remove()
{
/* Sanity checks */
- ASSERT(handle != NULL, return(NULL));
- ASSERT(handle->trans != NULL, return(NULL));
+ ASSERT(handle != NULL, return NULL);
+ ASSERT(handle->trans != NULL, return NULL);
return handle->trans->remove;
}
diff --git a/lib/libalpm/util.c b/lib/libalpm/util.c
index 430da92a..99dd3bea 100644
--- a/lib/libalpm/util.c
+++ b/lib/libalpm/util.c
@@ -53,7 +53,6 @@
/* libalpm */
#include "util.h"
#include "log.h"
-#include "package.h"
#include "alpm.h"
#include "alpm_list.h"
#include "handle.h"
@@ -65,14 +64,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 +86,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 +122,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 +136,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;);
@@ -175,7 +174,7 @@ cleanup:
fclose(in);
fclose(out);
FREE(buf);
- return(ret);
+ return ret;
}
/* Trim whitespace and newlines from a string
@@ -186,7 +185,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 +197,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 +206,7 @@ char *_alpm_strtrim(char *str)
}
*++pch = '\0';
- return(str);
+ return str;
}
/* Compression functions */
@@ -225,12 +224,12 @@ int _alpm_unpack_single(const char *archive, const char *prefix, const char *fn)
alpm_list_t *list = NULL;
int ret = 0;
if(fn == NULL) {
- return(1);
+ return 1;
}
list = alpm_list_add(list, (void *)fn);
ret = _alpm_unpack(archive, prefix, list, 1);
alpm_list_free(list);
- return(ret);
+ return ret;
}
/**
@@ -307,7 +306,7 @@ int _alpm_unpack(const char *archive, const char *prefix, alpm_list_t *list, int
char *found = alpm_list_find_str(list, prefix);
free(prefix);
if(!found) {
- if (archive_read_data_skip(_archive) != ARCHIVE_OK) {
+ if(archive_read_data_skip(_archive) != ARCHIVE_OK) {
ret = 1;
goto cleanup;
}
@@ -341,7 +340,7 @@ cleanup:
if(restore_cwd && chdir(cwd) != 0) {
_alpm_log(PM_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 +355,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,9 +381,9 @@ 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)
@@ -415,7 +414,7 @@ int _alpm_logaction(int usesyslog, FILE *f, const char *fmt, va_list args)
fflush(f);
}
- return(ret);
+ return ret;
}
int _alpm_run_chroot(const char *root, const char *path, char *const argv[])
@@ -532,7 +531,7 @@ cleanup:
_alpm_log(PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
}
- return(retval);
+ return retval;
}
int _alpm_ldconfig(const char *root)
@@ -550,14 +549,14 @@ int _alpm_ldconfig(const char *root)
}
}
- 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.
@@ -573,12 +572,12 @@ char *_alpm_filecache_find(const char* filename)
/* 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),
+ 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);
+ return retpath;
}
}
/* package wasn't found in any cachedir */
@@ -604,11 +603,11 @@ const char *_alpm_filecache_setup(void)
cachedir);
if(_alpm_makepath(cachedir) == 0) {
_alpm_log(PM_LOG_DEBUG, "using cachedir: %s\n", cachedir);
- return(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);
+ return cachedir;
}
}
@@ -617,7 +616,7 @@ const char *_alpm_filecache_setup(void)
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));
+ return alpm_list_getdata(tmp);
}
/** lstat wrapper that treats /path/dirsymlink/ the same as /path/dirsymlink.
@@ -641,7 +640,7 @@ int _alpm_lstat(const char *path, struct stat *buf)
ret = lstat(newpath, buf);
FREE(newpath);
- return(ret);
+ return ret;
}
#ifdef HAVE_LIBSSL
@@ -652,11 +651,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), RET_ERR(PM_ERR_MEMORY, 1));
if((f = fopen(path, "rb")) == NULL) {
free(buf);
- return(1);
+ return 1;
}
MD5_Init(&ctx);
@@ -672,11 +671,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
@@ -693,14 +692,14 @@ char SYMEXPORT *alpm_compute_md5sum(const char *filename)
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));
/* defined above for OpenSSL, otherwise defined in md5.h */
ret = md5_file(filename, output);
- if (ret > 0) {
+ if(ret > 0) {
RET_ERR(PM_ERR_NOT_A_FILE, NULL);
}
@@ -712,7 +711,7 @@ char SYMEXPORT *alpm_compute_md5sum(const char *filename)
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 +730,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,7 +752,7 @@ 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;
@@ -804,7 +803,7 @@ 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);
@@ -819,7 +818,7 @@ cleanup:
int ret = b->ret;
FREE(b->line);
memset(b, 0, sizeof(b));
- return(ret);
+ return ret;
}
}
@@ -833,12 +832,12 @@ int _alpm_splitname(const char *target, pmpkg_t *pkg)
const char *version, *end;
if(target == NULL || pkg == NULL) {
- return(-1);
+ return -1;
}
end = target + strlen(target);
/* remove any trailing '/' */
- while (*(end - 1) == '/') {
+ while(*(end - 1) == '/') {
--end;
}
@@ -847,7 +846,7 @@ int _alpm_splitname(const char *target, pmpkg_t *pkg)
for(version = end - 1; *version && *version != '-'; version--);
for(version = version - 1; *version && *version != '-'; version--);
if(*version != '-' || version == target) {
- return(-1);
+ return -1;
}
/* copy into fields and return */
@@ -865,7 +864,7 @@ int _alpm_splitname(const char *target, pmpkg_t *pkg)
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 +879,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 +896,9 @@ 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));
+ return atol(line);
}
#ifndef HAVE_STRNDUP
@@ -908,7 +907,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 +915,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..776cee4d 100644
--- a/lib/libalpm/util.h
+++ b/lib/libalpm/util.h
@@ -36,6 +36,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 */
@@ -63,7 +65,9 @@
#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)
+ return (ret); } while(0)
+
+#define DOUBLE_EQ(x, y) (fabs((x) - (y)) < DBL_EPSILON)
/**
* Used as a buffer/state holder for _alpm_archive_fgets().
@@ -113,6 +117,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: */