static gchar *
alpm_pkg_build_urls (pmpkg_t *pkg)
{
GString *string = g_string_new ("");
#ifdef ALPM_PACKAGE_URL
const gchar *name, *arch, *repo, *url;
#else
const gchar *url;
#endif
g_return_val_if_fail (pkg != NULL, NULL);
/* grab the URL of the package... */
url = alpm_pkg_get_url (pkg);
if (url != NULL) {
g_string_append_printf (string, "%s;Package website;", url);
}
#ifdef ALPM_PACKAGE_URL
/* ... and construct the distro URL if possible */
name = alpm_pkg_get_name (pkg);
arch = alpm_pkg_get_arch (pkg);
repo = alpm_db_get_name (alpm_pkg_get_db (pkg));
g_string_append_printf (string, ALPM_PACKAGE_URL ";Distribution page;",
repo, arch, name);
#endif
g_string_truncate (string, string->len - 1);
return g_string_free (string, FALSE);
}
void pu_fprint_pkgspec(FILE *stream, alpm_pkg_t *pkg)
{
const char *c;
switch(alpm_pkg_get_origin(pkg)) {
case ALPM_PKG_FROM_FILE:
c = alpm_pkg_get_filename(pkg);
if(strstr(c, "://")) {
fprintf(stream, "%s", alpm_pkg_get_filename(pkg));
} else {
char *real = realpath(c, NULL);
fprintf(stream, "file://%s", real);
free(real);
}
break;
case ALPM_PKG_FROM_LOCALDB:
fprintf(stream, "local/%s", alpm_pkg_get_name(pkg));
break;
case ALPM_PKG_FROM_SYNCDB:
fprintf(stream, "%s/%s",
alpm_db_get_name(alpm_pkg_get_db(pkg)), alpm_pkg_get_name(pkg));
break;
default:
/* no idea where this package came from, fall back to its name */
fputs(alpm_pkg_get_name(pkg), stream);
break;
}
}
static gboolean
pk_backend_match_details (alpm_pkg_t *pkg, GRegex *regex)
{
const gchar *desc;
alpm_db_t *db;
const alpm_list_t *i;
g_return_val_if_fail (pkg != NULL, FALSE);
g_return_val_if_fail (regex != NULL, FALSE);
/* match the name first... */
if (g_regex_match (regex, alpm_pkg_get_name (pkg), 0, NULL))
return TRUE;
/* ... then the description... */
desc = alpm_pkg_get_desc (pkg);
if (desc != NULL && g_regex_match (regex, desc, 0, NULL))
return TRUE;
/* ... then the database... */
db = alpm_pkg_get_db (pkg);
if (db != NULL && g_regex_match (regex, alpm_db_get_name (db),
G_REGEX_MATCH_ANCHORED, NULL))
return TRUE;
/* ... then the licenses */
for (i = alpm_pkg_get_licenses (pkg); i != NULL; i = i->next) {
if (g_regex_match (regex, i->data, G_REGEX_MATCH_ANCHORED, NULL))
return TRUE;
}
return FALSE;
}
/**
* Open a package changelog for reading. Similar to fopen in functionality,
* except that the returned 'file stream' is from the database.
* @param pkg the package (from db) to read the changelog
* @return a 'file stream' to the package changelog
*/
static void *_cache_changelog_open(alpm_pkg_t *pkg)
{
alpm_db_t *db = alpm_pkg_get_db(pkg);
char *clfile = _alpm_local_db_pkgpath(db, pkg, "changelog");
FILE *f = fopen(clfile, "r");
free(clfile);
return f;
}
static PyObject* pyalpm_package_get_db(AlpmPackage *self, void *closure) {
alpm_db_t* db;
CHECK_IF_INITIALIZED();
db = alpm_pkg_get_db(self->c_data);
if (db)
return pyalpm_db_from_pmdb(db);
else
Py_RETURN_NONE;
}
/**
* Open a package changelog for reading. Similar to fopen in functionality,
* except that the returned 'file stream' is from the database.
* @param pkg the package (from db) to read the changelog
* @return a 'file stream' to the package changelog
*/
static void *_cache_changelog_open(pmpkg_t *pkg)
{
char clfile[PATH_MAX];
snprintf(clfile, PATH_MAX, "%s/%s/%s-%s/changelog",
alpm_option_get_dbpath(pkg->handle),
alpm_db_get_name(alpm_pkg_get_db(pkg)),
alpm_pkg_get_name(pkg),
alpm_pkg_get_version(pkg));
return fopen(clfile, "r");
}
void print_packages(const alpm_list_t *packages)
{
const alpm_list_t *i;
if(!config->print_format) {
config->print_format = strdup("%l");
}
for(i = packages; i; i = alpm_list_next(i)) {
alpm_pkg_t *pkg = i->data;
char *string = strdup(config->print_format);
char *temp = string;
/* %n : pkgname */
if(strstr(temp, "%n")) {
string = strreplace(temp, "%n", alpm_pkg_get_name(pkg));
free(temp);
temp = string;
}
/* %v : pkgver */
if(strstr(temp, "%v")) {
string = strreplace(temp, "%v", alpm_pkg_get_version(pkg));
free(temp);
temp = string;
}
/* %l : location */
if(strstr(temp, "%l")) {
char *pkgloc = pkg_get_location(pkg);
string = strreplace(temp, "%l", pkgloc);
free(pkgloc);
free(temp);
temp = string;
}
/* %r : repo */
if(strstr(temp, "%r")) {
const char *repo = "local";
alpm_db_t *db = alpm_pkg_get_db(pkg);
if(db) {
repo = alpm_db_get_name(db);
}
string = strreplace(temp, "%r", repo);
free(temp);
temp = string;
}
/* %s : size */
if(strstr(temp, "%s")) {
char *size;
pm_asprintf(&size, "%jd", (intmax_t)pkg_get_size(pkg));
string = strreplace(temp, "%s", size);
free(size);
free(temp);
}
printf("%s\n", string);
free(string);
}
}
CAMLprim value oalpm_pkg_checkmd5sum ( value package )
{
pmpkg_t * pkg;
pmdb_t * db;
CAMLparam1( package );
pkg = Package_val( package );
db = alpm_pkg_get_db( pkg );
if ( strcmp( alpm_db_get_name( db ), "local" ) == 0 ) {
caml_failwith( FAIL_CHECK_LOCALPKG );
}
OALPMreturn( alpm_pkg_checkmd5sum( pkg ));
}
/* returns package info as list of strings */
static alpm_list_t *create_verbose_row(pm_target_t *target)
{
char *str;
off_t size = 0;
double human_size;
const char *label;
alpm_list_t *ret = NULL;
/* a row consists of the package name, */
if(target->install) {
const alpm_db_t *db = alpm_pkg_get_db(target->install);
if(db) {
pm_asprintf(&str, "%s/%s", alpm_db_get_name(db), alpm_pkg_get_name(target->install));
} else {
pm_asprintf(&str, "%s", alpm_pkg_get_name(target->install));
}
} else {
pm_asprintf(&str, "%s", alpm_pkg_get_name(target->remove));
}
ret = alpm_list_add(ret, str);
/* old and new versions */
pm_asprintf(&str, "%s",
target->remove != NULL ? alpm_pkg_get_version(target->remove) : "");
ret = alpm_list_add(ret, str);
pm_asprintf(&str, "%s",
target->install != NULL ? alpm_pkg_get_version(target->install) : "");
ret = alpm_list_add(ret, str);
/* and size */
size -= target->remove ? alpm_pkg_get_isize(target->remove) : 0;
size += target->install ? alpm_pkg_get_isize(target->install) : 0;
human_size = humanize_size(size, 'M', 2, &label);
pm_asprintf(&str, "%.2f %s", human_size, label);
ret = alpm_list_add(ret, str);
size = target->install ? alpm_pkg_download_size(target->install) : 0;
if(size != 0) {
human_size = humanize_size(size, 'M', 2, &label);
pm_asprintf(&str, "%.2f %s", human_size, label);
} else {
str = NULL;
}
ret = alpm_list_add(ret, str);
return ret;
}
static char *pkg_get_location(alpm_pkg_t *pkg)
{
alpm_list_t *servers;
char *string = NULL;
switch(config->op) {
case PM_OP_SYNC:
servers = alpm_db_get_servers(alpm_pkg_get_db(pkg));
if(servers) {
pm_asprintf(&string, "%s/%s", servers->data,
alpm_pkg_get_filename(pkg));
return string;
}
case PM_OP_UPGRADE:
return strdup(alpm_pkg_get_filename(pkg));
default:
pm_asprintf(&string, "%s-%s", alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
return string;
}
}
static int check_literal(alpm_handle_t *handle, alpm_pkg_t *lpkg,
alpm_pkg_t *spkg, int enable_downgrade)
{
/* 1. literal was found in sdb */
int cmp = _alpm_pkg_compare_versions(spkg, lpkg);
if(cmp > 0) {
_alpm_log(handle, ALPM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
lpkg->name, lpkg->version, spkg->version);
/* check IgnorePkg/IgnoreGroup */
if(alpm_pkg_should_ignore(handle, spkg)
|| alpm_pkg_should_ignore(handle, lpkg)) {
_alpm_log(handle, ALPM_LOG_WARNING, _("%s: ignoring package upgrade (%s => %s)\n"),
lpkg->name, lpkg->version, spkg->version);
} else {
_alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
spkg->name, spkg->version);
return 1;
}
} else if(cmp < 0) {
if(enable_downgrade) {
/* check IgnorePkg/IgnoreGroup */
if(alpm_pkg_should_ignore(handle, spkg)
|| alpm_pkg_should_ignore(handle, lpkg)) {
_alpm_log(handle, ALPM_LOG_WARNING, _("%s: ignoring package downgrade (%s => %s)\n"),
lpkg->name, lpkg->version, spkg->version);
} else {
_alpm_log(handle, ALPM_LOG_WARNING, _("%s: downgrading from version %s to version %s\n"),
lpkg->name, lpkg->version, spkg->version);
return 1;
}
} else {
alpm_db_t *sdb = alpm_pkg_get_db(spkg);
_alpm_log(handle, ALPM_LOG_WARNING, _("%s: local (%s) is newer than %s (%s)\n"),
lpkg->name, lpkg->version, sdb->treename, spkg->version);
}
}
return 0;
}
/**
* Open a package mtree file for reading.
* @param pkg the local package to read the changelog of
* @return a archive structure for the package mtree file
*/
static struct archive *_cache_mtree_open(alpm_pkg_t *pkg)
{
int r;
struct archive *mtree;
alpm_db_t *db = alpm_pkg_get_db(pkg);
char *mtfile = _alpm_local_db_pkgpath(db, pkg, "mtree");
if(access(mtfile, F_OK) != 0) {
/* there is no mtree file for this package */
goto error;
}
if((mtree = archive_read_new()) == NULL) {
pkg->handle->pm_errno = ALPM_ERR_LIBARCHIVE;
goto error;
}
_alpm_archive_read_support_filter_all(mtree);
archive_read_support_format_mtree(mtree);
if((r = _alpm_archive_read_open_file(mtree, mtfile, ALPM_BUFFER_SIZE))) {
_alpm_log(pkg->handle, ALPM_LOG_ERROR, _("error while reading file %s: %s\n"),
mtfile, archive_error_string(mtree));
pkg->handle->pm_errno = ALPM_ERR_LIBARCHIVE;
_alpm_archive_read_free(mtree);
goto error;
}
free(mtfile);
return mtree;
error:
free(mtfile);
return NULL;
}
gchar *
alpm_pkg_build_id (alpm_pkg_t *pkg)
{
const gchar *name, *version, *arch, *repo;
g_return_val_if_fail (pkg != NULL, NULL);
name = alpm_pkg_get_name (pkg);
version = alpm_pkg_get_version (pkg);
arch = alpm_pkg_get_arch (pkg);
if (arch == NULL) {
arch = "any";
}
/* TODO: check correctness */
if (alpm_pkg_get_origin (pkg) == ALPM_PKG_FROM_SYNCDB) {
repo = alpm_db_get_name (alpm_pkg_get_db (pkg));
} else {
repo = "installed";
}
return pk_package_id_build (name, version, arch, repo);
}
static int print_pkg(alpm_pkg_t *pkg, const char *format) {
const char *f, *end;
char fmt[64], buf[64];
int len, out = 0;
end = format + strlen(format);
for (f = format; f < end; f++) {
len = 0;
if (*f == '%') {
len = strspn(f + 1 + len, printf_flags);
len += strspn(f + 1 + len, digits);
snprintf(fmt, len + 3, "%ss", f);
fmt[len + 1] = 's';
f += len + 1;
switch (*f) {
/* simple attributes */
case 'f': /* filename */
out += printf(fmt, alpm_pkg_get_filename(pkg));
break;
case 'n': /* package name */
out += printf(fmt, alpm_pkg_get_name(pkg));
break;
case 'v': /* version */
out += printf(fmt, alpm_pkg_get_version(pkg));
break;
case 'd': /* description */
out += printf(fmt, alpm_pkg_get_desc(pkg));
break;
case 'u': /* project url */
out += printf(fmt, alpm_pkg_get_url(pkg));
break;
case 'p': /* packager name */
out += printf(fmt, alpm_pkg_get_packager(pkg));
break;
case 's': /* md5sum */
out += printf(fmt, alpm_pkg_get_md5sum(pkg));
break;
case 'a': /* architecutre */
out += printf(fmt, alpm_pkg_get_arch(pkg));
break;
case 'i': /* has install scriptlet? */
out += printf(fmt, alpm_pkg_has_scriptlet(pkg) ? "yes" : "no");
break;
case 'r': /* repo */
out += printf(fmt, alpm_db_get_name(alpm_pkg_get_db(pkg)));
break;
case 'w': /* install reason */
out += printf(fmt, alpm_pkg_get_reason(pkg) ? "dependency" : "explicit");
break;
case '!': /* result number */
snprintf(buf, sizeof(buf), "%d", opt_pkgcounter++);
out += printf(fmt, buf);
break;
case 'g': /* base64 gpg sig */
out += printf(fmt, alpm_pkg_get_base64_sig(pkg));
break;
case 'h': /* sha256sum */
out += printf(fmt, alpm_pkg_get_sha256sum(pkg));
break;
/* times */
case 'b': /* build date */
out += print_time(alpm_pkg_get_builddate(pkg));
break;
case 'l': /* install date */
out += print_time(alpm_pkg_get_installdate(pkg));
break;
/* sizes */
case 'k': /* download size */
out += printf(fmt, size_to_string(alpm_pkg_get_size(pkg)));
break;
case 'm': /* install size */
out += printf(fmt, size_to_string(alpm_pkg_get_isize(pkg)));
break;
/* lists */
case 'F': /* files */
out += print_filelist(alpm_pkg_get_files(pkg));
break;
case 'N': /* requiredby */
out += print_list(alpm_pkg_compute_requiredby(pkg), NULL);
break;
case 'L': /* licenses */
out += print_list(alpm_pkg_get_licenses(pkg), NULL);
break;
case 'G': /* groups */
out += print_list(alpm_pkg_get_groups(pkg), NULL);
break;
case 'E': /* depends (shortdeps) */
out += print_list(alpm_pkg_get_depends(pkg), (extractfn)alpm_dep_get_name);
break;
case 'D': /* depends */
out += print_list(alpm_pkg_get_depends(pkg), (extractfn)alpm_dep_compute_string);
break;
case 'O': /* optdepends */
out += print_list(alpm_pkg_get_optdepends(pkg), (extractfn)format_optdep);
break;
case 'o': /* optdepends (shortdeps) */
out += print_list(alpm_pkg_get_optdepends(pkg), (extractfn)alpm_dep_get_name);
break;
case 'C': /* conflicts */
out += print_list(alpm_pkg_get_conflicts(pkg), (extractfn)alpm_dep_get_name);
break;
case 'S': /* provides (shortdeps) */
out += print_list(alpm_pkg_get_provides(pkg), (extractfn)alpm_dep_get_name);
break;
case 'P': /* provides */
out += print_list(alpm_pkg_get_provides(pkg), (extractfn)alpm_dep_compute_string);
break;
case 'R': /* replaces */
out += print_list(alpm_pkg_get_replaces(pkg), (extractfn)alpm_dep_get_name);
break;
case 'B': /* backup */
out += print_list(alpm_pkg_get_backup(pkg), alpm_backup_get_name);
break;
case 'V': /* package validation */
out += print_allocated_list(get_validation_method(pkg), NULL);
break;
case 'M': /* modified */
out += print_allocated_list(get_modified_files(pkg), NULL);
break;
case '%':
fputc('%', stdout);
out++;
break;
default:
fputc('?', stdout);
out++;
break;
}
} else if (*f == '\\') {
char esc[3] = { f[0], f[1], '\0' };
out += print_escaped(esc);
++f;
} else {
fputc(*f, stdout);
out++;
}
}
/* only print a delimeter if any package data was outputted */
if (out > 0) {
print_escaped(opt_delim);
}
return !out;
}
static gboolean
pk_backend_get_update_detail_thread (PkBackend *self)
{
gchar **packages;
GError *error = NULL;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (localdb != NULL, FALSE);
packages = pk_backend_get_strv (self, "package_ids");
g_return_val_if_fail (packages != NULL, FALSE);
/* collect details about updates */
for (; *packages != NULL; ++packages) {
pmpkg_t *pkg, *old;
pmdb_t *db;
gchar *upgrades, *replaces, *urls;
const gchar *reason;
PkRestartEnum restart;
PkUpdateStateEnum state;
GTimeVal built = { 0 }, installed = { 0 };
gchar *issued, *updated;
if (pk_backend_cancelled (self)) {
break;
}
pkg = pk_backend_find_pkg (self, *packages, &error);
if (pkg == NULL) {
break;
}
old = alpm_db_get_pkg (localdb, alpm_pkg_get_name (pkg));
if (old != NULL) {
upgrades = alpm_pkg_build_id (old);
if (alpm_pkg_same_pkgver (pkg, old)) {
reason = "Update to a newer release";
} else {
reason = "Update to a new upstream version";
}
} else {
upgrades = NULL;
reason = "Install to replace an older package";
}
db = alpm_pkg_get_db (pkg);
replaces = alpm_pkg_build_replaces (pkg);
urls = alpm_pkg_build_urls (pkg);
if (g_str_has_prefix (alpm_pkg_get_name (pkg), "kernel")) {
restart = PK_RESTART_ENUM_SYSTEM;
} else {
restart = PK_RESTART_ENUM_NONE;
}
if (g_str_has_suffix (alpm_db_get_name (db), "testing")) {
state = PK_UPDATE_STATE_ENUM_TESTING;
} else {
state = PK_UPDATE_STATE_ENUM_STABLE;
}
built.tv_sec = alpm_pkg_get_builddate (pkg);
if (built.tv_sec > 0) {
issued = g_time_val_to_iso8601 (&built);
} else {
issued = NULL;
}
if (upgrades != NULL) {
installed.tv_sec = alpm_pkg_get_installdate (old);
if (installed.tv_sec > 0) {
updated = g_time_val_to_iso8601 (&installed);
} else {
updated = NULL;
}
} else {
updated = NULL;
}
pk_backend_update_detail (self, *packages, upgrades, replaces,
urls, NULL, NULL, restart, reason,
NULL, state, issued, updated);
g_free (issued);
g_free (updated);
g_free (urls);
g_free (replaces);
g_free (upgrades);
}
return pk_backend_finish (self, error);
}
int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
{
alpm_list_t *i;
alpm_list_t *deltas = NULL;
size_t numtargs, current = 0, replaces = 0;
int errors;
alpm_trans_t *trans = handle->trans;
if(download_files(handle, &deltas)) {
alpm_list_free(deltas);
return -1;
}
if(validate_deltas(handle, deltas, data)) {
alpm_list_free(deltas);
return -1;
}
alpm_list_free(deltas);
/* Check integrity of packages */
numtargs = alpm_list_count(trans->add);
EVENT(trans, ALPM_TRANS_EVT_INTEGRITY_START, NULL, NULL);
errors = 0;
for(i = trans->add; i; i = i->next, current++) {
alpm_pkg_t *spkg = i->data;
int percent = (current * 100) / numtargs;
const char *filename;
char *filepath;
alpm_siglevel_t level;
PROGRESS(trans, ALPM_TRANS_PROGRESS_INTEGRITY_START, "", percent,
numtargs, current);
if(spkg->origin == PKG_FROM_FILE) {
continue; /* pkg_load() has been already called, this package is valid */
}
filename = alpm_pkg_get_filename(spkg);
filepath = _alpm_filecache_find(handle, filename);
alpm_db_t *sdb = alpm_pkg_get_db(spkg);
level = alpm_db_get_siglevel(sdb);
/* 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(handle, ALPM_LOG_DEBUG,
"replacing pkgcache entry with package file for target %s\n",
spkg->name);
alpm_pkg_t *pkgfile =_alpm_pkg_load_internal(handle, filepath, 1, spkg->md5sum,
spkg->base64_sig, level);
if(!pkgfile) {
errors++;
*data = alpm_list_add(*data, strdup(filename));
FREE(filepath);
continue;
}
FREE(filepath);
pkgfile->reason = spkg->reason; /* copy over install reason */
i->data = pkgfile;
_alpm_pkg_free_trans(spkg); /* spkg has been removed from the target list */
}
PROGRESS(trans, ALPM_TRANS_PROGRESS_INTEGRITY_START, "", 100,
numtargs, current);
EVENT(trans, ALPM_TRANS_EVT_INTEGRITY_DONE, NULL, NULL);
if(errors) {
RET_ERR(handle, ALPM_ERR_PKG_INVALID, -1);
}
if(trans->flags & ALPM_TRANS_FLAG_DOWNLOADONLY) {
return 0;
}
trans->state = STATE_COMMITING;
replaces = alpm_list_count(trans->remove);
/* fileconflict check */
if(!(trans->flags & ALPM_TRANS_FLAG_FORCE)) {
EVENT(trans, ALPM_TRANS_EVT_FILECONFLICTS_START, NULL, NULL);
_alpm_log(handle, ALPM_LOG_DEBUG, "looking for file conflicts\n");
alpm_list_t *conflict = _alpm_db_find_fileconflicts(handle,
trans->add, trans->remove);
if(conflict) {
if(data) {
*data = conflict;
} else {
alpm_list_free_inner(conflict, (alpm_list_fn_free)_alpm_fileconflict_free);
alpm_list_free(conflict);
}
RET_ERR(handle, ALPM_ERR_FILE_CONFLICTS, -1);
}
EVENT(trans, ALPM_TRANS_EVT_FILECONFLICTS_DONE, NULL, NULL);
}
/* check available disk space */
if(handle->checkspace) {
EVENT(trans, ALPM_TRANS_EVT_DISKSPACE_START, NULL, NULL);
_alpm_log(handle, ALPM_LOG_DEBUG, "checking available disk space\n");
if(_alpm_check_diskspace(handle) == -1) {
_alpm_log(handle, ALPM_LOG_ERROR, "%s\n", _("not enough free disk space"));
return -1;
}
EVENT(trans, ALPM_TRANS_EVT_DISKSPACE_DONE, NULL, NULL);
}
/* remove conflicting and to-be-replaced packages */
if(replaces) {
_alpm_log(handle, ALPM_LOG_DEBUG, "removing conflicting and to-be-replaced packages\n");
/* we want the frontend to be aware of commit details */
if(_alpm_remove_packages(handle) == -1) {
_alpm_log(handle, ALPM_LOG_ERROR, _("could not commit removal transaction\n"));
return -1;
}
}
/* install targets */
_alpm_log(handle, ALPM_LOG_DEBUG, "installing packages\n");
if(_alpm_upgrade_packages(handle) == -1) {
_alpm_log(handle, ALPM_LOG_ERROR, _("could not commit transaction\n"));
return -1;
}
return 0;
}
/**
* Display the details of a package.
* Extra information entails 'required by' info for sync packages and backup
* files info for local packages.
* @param pkg package to display information for
* @param from the type of package we are dealing with
* @param extra should we show extra information
*/
void dump_pkg_full(alpm_pkg_t *pkg, int extra)
{
unsigned short cols;
time_t bdate, idate;
alpm_pkgfrom_t from;
double size;
char bdatestr[50] = "", idatestr[50] = "";
const char *label, *reason;
alpm_list_t *validation = NULL, *requiredby = NULL, *optionalfor = NULL;
from = alpm_pkg_get_origin(pkg);
/* set variables here, do all output below */
bdate = (time_t)alpm_pkg_get_builddate(pkg);
if(bdate) {
strftime(bdatestr, 50, "%c", localtime(&bdate));
}
idate = (time_t)alpm_pkg_get_installdate(pkg);
if(idate) {
strftime(idatestr, 50, "%c", localtime(&idate));
}
switch(alpm_pkg_get_reason(pkg)) {
case ALPM_PKG_REASON_EXPLICIT:
reason = _("Explicitly installed");
break;
case ALPM_PKG_REASON_DEPEND:
reason = _("Installed as a dependency for another package");
break;
default:
reason = _("Unknown");
break;
}
alpm_pkgvalidation_t v = alpm_pkg_get_validation(pkg);
if(v) {
if(v & ALPM_PKG_VALIDATION_NONE) {
validation = alpm_list_add(validation, _("None"));
} else {
if(v & ALPM_PKG_VALIDATION_MD5SUM) {
validation = alpm_list_add(validation, _("MD5 Sum"));
}
if(v & ALPM_PKG_VALIDATION_SHA256SUM) {
validation = alpm_list_add(validation, _("SHA256 Sum"));
}
if(v & ALPM_PKG_VALIDATION_SIGNATURE) {
validation = alpm_list_add(validation, _("Signature"));
}
}
} else {
validation = alpm_list_add(validation, _("Unknown"));
}
if(extra || from == ALPM_PKG_FROM_LOCALDB) {
/* compute this here so we don't get a pause in the middle of output */
requiredby = alpm_pkg_compute_requiredby(pkg);
optionalfor = alpm_pkg_compute_optionalfor(pkg);
}
cols = getcols(fileno(stdout));
/* actual output */
if(from == ALPM_PKG_FROM_SYNCDB) {
string_display(_("Repository :"),
alpm_db_get_name(alpm_pkg_get_db(pkg)), cols);
}
string_display(_("Name :"), alpm_pkg_get_name(pkg), cols);
string_display(_("Version :"), alpm_pkg_get_version(pkg), cols);
string_display(_("Description :"), alpm_pkg_get_desc(pkg), cols);
string_display(_("Architecture :"), alpm_pkg_get_arch(pkg), cols);
string_display(_("URL :"), alpm_pkg_get_url(pkg), cols);
list_display(_("Licenses :"), alpm_pkg_get_licenses(pkg), cols);
list_display(_("Groups :"), alpm_pkg_get_groups(pkg), cols);
deplist_display(_("Provides :"), alpm_pkg_get_provides(pkg), cols);
deplist_display(_("Depends On :"), alpm_pkg_get_depends(pkg), cols);
optdeplist_display(pkg, cols);
if(extra || from == ALPM_PKG_FROM_LOCALDB) {
list_display(_("Required By :"), requiredby, cols);
list_display(_("Optional For :"), optionalfor, cols);
}
deplist_display(_("Conflicts With :"), alpm_pkg_get_conflicts(pkg), cols);
deplist_display(_("Replaces :"), alpm_pkg_get_replaces(pkg), cols);
size = humanize_size(alpm_pkg_get_size(pkg), '\0', 2, &label);
if(from == ALPM_PKG_FROM_SYNCDB) {
printf("%s%s%s %6.2f %s\n", config->colstr.title, _("Download Size :"),
config->colstr.nocolor, size, label);
} else if(from == ALPM_PKG_FROM_FILE) {
printf("%s%s%s %6.2f %s\n", config->colstr.title, _("Compressed Size:"),
config->colstr.nocolor, size, label);
} else {
// autodetect size for "Installed Size"
label = "\0";
}
size = humanize_size(alpm_pkg_get_isize(pkg), label[0], 2, &label);
printf("%s%s%s %6.2f %s\n", config->colstr.title, _("Installed Size :"),
config->colstr.nocolor, size, label);
string_display(_("Packager :"), alpm_pkg_get_packager(pkg), cols);
string_display(_("Build Date :"), bdatestr, cols);
if(from == ALPM_PKG_FROM_LOCALDB) {
string_display(_("Install Date :"), idatestr, cols);
string_display(_("Install Reason :"), reason, cols);
}
if(from == ALPM_PKG_FROM_FILE || from == ALPM_PKG_FROM_LOCALDB) {
string_display(_("Install Script :"),
alpm_pkg_has_scriptlet(pkg) ? _("Yes") : _("No"), cols);
}
if(from == ALPM_PKG_FROM_SYNCDB && extra) {
const char *base64_sig = alpm_pkg_get_base64_sig(pkg);
alpm_list_t *keys = NULL;
if(base64_sig) {
unsigned char *decoded_sigdata = NULL;
size_t data_len;
alpm_decode_signature(base64_sig, &decoded_sigdata, &data_len);
alpm_extract_keyid(config->handle, alpm_pkg_get_name(pkg),
decoded_sigdata, data_len, &keys);
} else {
keys = alpm_list_add(keys, _("None"));
}
string_display(_("MD5 Sum :"), alpm_pkg_get_md5sum(pkg), cols);
string_display(_("SHA256 Sum :"), alpm_pkg_get_sha256sum(pkg), cols);
list_display(_("Signatures :"), keys, cols);
} else {
list_display(_("Validated By :"), validation, cols);
}
if(from == ALPM_PKG_FROM_FILE) {
alpm_siglist_t siglist;
int err = alpm_pkg_check_pgp_signature(pkg, &siglist);
if(err && alpm_errno(config->handle) == ALPM_ERR_SIG_MISSING) {
string_display(_("Signatures :"), _("None"), cols);
} else if(err) {
string_display(_("Signatures :"),
alpm_strerror(alpm_errno(config->handle)), cols);
} else {
signature_display(_("Signatures :"), &siglist, cols);
}
alpm_siglist_cleanup(&siglist);
}
/* Print additional package info if info flag passed more than once */
if(from == ALPM_PKG_FROM_LOCALDB && extra) {
dump_pkg_backups(pkg);
}
/* final newline to separate packages */
printf("\n");
FREELIST(requiredby);
alpm_list_free(validation);
}
alpm_list_t *resolve_dependencies(struct pw_hashdb *hashdb, alpm_list_t *packages)
{
alpm_list_t *i, *k, *m, *q;
alpm_list_t *deps, *newdeps;
pmpkg_t *pkg;
struct pkgpair pkgpair;
struct pkgpair *pkgpair_ptr;
char pkgbuild[PATH_MAX];
struct stat st;
newdeps = NULL;
for (i = packages; i; i = i->next) {
snprintf(pkgbuild, PATH_MAX, "%s/PKGBUILD", i->data);
/* Grab the list of new dependencies from PKGBUILD */
deps = grab_dependencies(pkgbuild);
if (!deps) {
continue;
}
if (config->verbose) {
printf("\nResolving dependencies for %s\n", i->data);
}
for (k = deps; k; k = k->next) {
pkgpair.pkgname = k->data;
/* Check against newdeps */
if (alpm_list_find_str(newdeps, k->data)) {
continue;
}
/* Check against localdb */
if (hash_search(hashdb->local, &pkgpair)) {
if (config->verbose) {
printf("%s%s - Already installed\n", TAB, k->data);
}
continue;
}
/* Check against sync dbs */
pkgpair_ptr = hash_search(hashdb->sync, &pkgpair);
if (pkgpair_ptr) {
if (config->verbose) {
printf("%s%s can be found in %s repo\n", TAB, k->data,
alpm_db_get_name(alpm_pkg_get_db(pkgpair_ptr->pkg)));
}
continue;
}
/* Check against provides */
pkgpair_ptr = hashbst_tree_search(hashdb->local_provides, k->data,
hashdb->local, provides_search);
if (pkgpair_ptr) {
if (config->verbose) {
printf("%s%s is provided by %s\n", TAB, k->data, pkgpair_ptr->pkgname);
}
continue;
}
pkgpair_ptr = hashbst_tree_search(hashdb->sync_provides, k->data,
hashdb->sync, provides_search);
if (pkgpair_ptr) {
if (config->verbose) {
printf("%s%s is provided by %s\n", TAB, k->data, pkgpair_ptr->pkgname);
}
continue;
}
/* Check the directory for pkg/PKGBUILD */
snprintf(pkgbuild, PATH_MAX, "%s/PKGBUILD", k->data);
if (!stat(pkgbuild, &st)) {
if (config->verbose) {
printf("%s%s has been downloaded\n", TAB, k->data);
}
continue;
}
/* Add to newdeps */
newdeps = alpm_list_add(newdeps, strdup(k->data));
if (config->verbose) {
printf("%s%s will be downloaded from the AUR\n", TAB, k->data);
}
}
/* Free deps */
FREELIST(deps);
}
return newdeps;
}
void pacman_pkgdump(pmpkg_t *pkg, enum pkgfrom_t from)
{
static const char *datefmt = "%a %d %b %Y %I:%M:%S %p %Z";
alpm_list_t *i, *results = NULL;
pmdb_t *db;
pmdepend_t *dep;
pmpkgreason_t reason;
int has_script;
time_t inst_time;
struct tm tm_st;
char installdate[60];
char builddate[60];
db = alpm_pkg_get_db(pkg);
if (!db) {
return;
}
memset(&tm_st, 0, sizeof(struct tm));
inst_time = alpm_pkg_get_builddate(pkg);
localtime_r(&inst_time, &tm_st);
strftime(builddate, 60, datefmt, &tm_st);
/* Local pkg specific */
if (from == PKG_FROM_LOCAL) {
has_script = alpm_pkg_has_scriptlet(pkg);
reason = alpm_pkg_get_reason(pkg);
memset(&tm_st, 0, sizeof(struct tm));
inst_time = alpm_pkg_get_installdate(pkg);
localtime_r(&inst_time, &tm_st);
strftime(installdate, 60, datefmt, &tm_st);
}
if (from == PKG_FROM_SYNC) {
printf("%s%s ", color.bold, REPO);
const char *repo = alpm_db_get_name(db);
if (!strcmp(repo, "core")) {
printf("%s", color.bred);
} else if (!strcmp(repo, "extra")) {
printf("%s", color.bgreen);
} else {
printf("%s", color.bmag);
}
printf("%s%s\n", repo, color.nocolor);
}
printf("%s%s%s %s%s%s\n", color.bold, NAME, color.nocolor,
color.bold, alpm_pkg_get_name(pkg), color.nocolor);
printf("%s%s %s%s%s\n", color.bold, VERSION, color.bgreen,
alpm_pkg_get_version(pkg), color.nocolor);
printf("%s%s %s%s%s\n", color.bold, URL, color.bcyan,
alpm_pkg_get_url(pkg), color.nocolor);
print_list_prefix(alpm_pkg_get_licenses(pkg), LICENSES);
print_list_prefix(alpm_pkg_get_groups(pkg), GROUPS);
print_list_prefix(alpm_pkg_get_provides(pkg), PROVIDES);
print_list_deps(alpm_pkg_get_depends(pkg), DEPS);
print_list_break(alpm_pkg_get_optdepends(pkg), OPTDEPS);
if (from == PKG_FROM_LOCAL) {
results = alpm_pkg_compute_requiredby(pkg);
print_list_prefix(results, REQBY);
}
print_list_prefix(alpm_pkg_get_conflicts(pkg), CONFLICTS);
print_list_prefix(alpm_pkg_get_replaces(pkg), REPLACES);
if (from == PKG_FROM_SYNC) {
humanize_size(alpm_pkg_get_size(pkg), DLSZ);
}
humanize_size(alpm_pkg_get_isize(pkg), INSTSZ);
printf("%s%s%s %s\n", color.bold, PKGER, color.nocolor,
alpm_pkg_get_packager(pkg));
printf("%s%s%s %s\n", color.bold, ARCH, color.nocolor, alpm_pkg_get_arch(pkg));
printf("%s%s%s %s\n", color.bold, BDATE, color.nocolor, builddate);
if (from == PKG_FROM_LOCAL) {
printf("%s%s%s %s\n", color.bold, IDATE, color.nocolor, installdate);
printf("%s%s%s ", color.bold, REASON, color.nocolor);
switch (reason) {
case PM_PKG_REASON_EXPLICIT:
printf("Explicitly installed");
break;
case PM_PKG_REASON_DEPEND:
printf("Installed as a dependency for another package");
break;
default:
printf("Unknown");
break;
}
printf("\n");
printf("%s%s%s %s\n", color.bold, SCRIPT, color.nocolor,
has_script ? "Yes" : "No");
}
if (from == PKG_FROM_SYNC) {
printf("%s%s%s %s\n", color.bold, MD5SUM, color.nocolor,
alpm_pkg_get_md5sum(pkg));
}
printf("%s%s%s %s\n", color.bold, DESC, color.nocolor, alpm_pkg_get_desc(pkg));
FREELIST(results);
}
CAMLprim value oalpm_pkg_get_db ( value package )
{
CAMLparam1( package );
CAMLreturn( alloc_alpm_db( alpm_pkg_get_db( Package_val( package ))));
}
g_string_append_printf (string, "&%s", package);
}
}
}
if (string == NULL)
return NULL;
return g_string_free (string, FALSE);
}
static gchar **
pk_alpm_pkg_build_urls (alpm_pkg_t *pkg)
{
gchar **urls = g_new0 (gchar *, 2);
urls[0] = g_strdup_printf ("http://www.archlinux.org/packages/%s/%s/%s/",
alpm_db_get_name (alpm_pkg_get_db (pkg)),
alpm_pkg_get_arch (pkg),
alpm_pkg_get_name (pkg));
return urls;
}
static gboolean
pk_alpm_pkg_same_pkgver (alpm_pkg_t *a, alpm_pkg_t *b)
{
const gchar *version_a, *version_b, *last_a, *last_b;
gsize length_a, length_b;
g_return_val_if_fail (a != NULL, (b == NULL));
g_return_val_if_fail (b != NULL, FALSE);
version_a = alpm_pkg_get_version (a);
